From 10c47ef2af59dfba47633520faa9302af90a9ae7 Mon Sep 17 00:00:00 2001
From: scuri <scuri>
Date: Tue, 26 Jan 2010 15:56:35 +0000
Subject: *** empty log message ***
---
src/libtiff/t4.h | 2 +-
src/libtiff/tif_aux.c | 18 +-
src/libtiff/tif_close.c | 22 +-
src/libtiff/tif_codec.c | 9 +-
src/libtiff/tif_color.c | 2 +-
src/libtiff/tif_compress.c | 24 +-
src/libtiff/tif_dir.c | 229 +-
src/libtiff/tif_dir.h | 77 +-
src/libtiff/tif_dirinfo.c | 163 +-
src/libtiff/tif_dirread.c | 867 +++-----
src/libtiff/tif_dirwrite.c | 322 +--
src/libtiff/tif_dumpmode.c | 6 +-
src/libtiff/tif_error.c | 2 +-
src/libtiff/tif_extension.c | 2 +-
src/libtiff/tif_fax3.c | 129 +-
src/libtiff/tif_fax3.h | 2 +-
src/libtiff/tif_flush.c | 2 +-
src/libtiff/tif_getimage.c | 2003 +++++++++---------
src/libtiff/tif_jpeg.c | 401 ++--
src/libtiff/tif_luv.c | 38 +-
src/libtiff/tif_lzw.c | 48 +-
src/libtiff/tif_next.c | 39 +-
src/libtiff/tif_ojpeg.c | 4926 ++++++++++++++++++++++---------------------
src/libtiff/tif_open.c | 19 +-
src/libtiff/tif_packbits.c | 6 +-
src/libtiff/tif_pixarlog.c | 34 +-
src/libtiff/tif_predict.c | 219 +-
src/libtiff/tif_predict.h | 16 +-
src/libtiff/tif_print.c | 8 +-
src/libtiff/tif_read.c | 375 ++--
src/libtiff/tif_strip.c | 85 +-
src/libtiff/tif_swab.c | 2 +-
src/libtiff/tif_thunder.c | 2 +-
src/libtiff/tif_tile.c | 2 +-
src/libtiff/tif_version.c | 2 +-
src/libtiff/tif_warning.c | 2 +-
src/libtiff/tif_write.c | 108 +-
src/libtiff/tif_zip.c | 64 +-
src/libtiff/tiff.h | 4 +-
src/libtiff/tiffio.h | 92 +-
src/libtiff/tiffiop.h | 49 +-
src/libtiff/tiffvers.h | 4 +-
42 files changed, 4787 insertions(+), 5639 deletions(-)
(limited to 'src')
diff --git a/src/libtiff/t4.h b/src/libtiff/t4.h
index b8a2b9e..63e5567 100644
--- a/src/libtiff/t4.h
+++ b/src/libtiff/t4.h
@@ -1,4 +1,4 @@
-/* $Id: t4.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: t4.h,v 1.4 2010/01/26 15:56:35 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_aux.c b/src/libtiff/tif_aux.c
index 7500295..2012f19 100644
--- a/src/libtiff/tif_aux.c
+++ b/src/libtiff/tif_aux.c
@@ -1,4 +1,4 @@
-/* $Id: tif_aux.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_aux.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@@ -34,8 +34,7 @@
#include <math.h>
tdata_t
-_TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
- size_t nmemb, size_t elem_size, const char* what)
+_TIFFCheckMalloc(TIFF* tif, size_t nmemb, size_t elem_size, const char* what)
{
tdata_t cp = NULL;
tsize_t bytes = nmemb * elem_size;
@@ -44,19 +43,12 @@ _TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
* XXX: Check for integer overflow.
*/
if (nmemb && elem_size && bytes / elem_size == nmemb)
- cp = _TIFFrealloc(buffer, bytes);
+ cp = _TIFFmalloc(bytes);
if (cp == NULL)
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "No space %s", what);
-
- return cp;
-}
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space %s", what);
-tdata_t
-_TIFFCheckMalloc(TIFF* tif, size_t nmemb, size_t elem_size, const char* what)
-{
- return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
+ return (cp);
}
static int
diff --git a/src/libtiff/tif_close.c b/src/libtiff/tif_close.c
index a594de1..ad8289c 100644
--- a/src/libtiff/tif_close.c
+++ b/src/libtiff/tif_close.c
@@ -1,4 +1,4 @@
-/* $Id: tif_close.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_close.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -54,27 +54,27 @@ TIFFCleanup(TIFF* tif)
TIFFFreeDirectory(tif);
if (tif->tif_dirlist)
- _TIFFfree(tif->tif_dirlist);
-
+ _TIFFfree(tif->tif_dirlist);
+
/* Clean up client info links */
while( tif->tif_clientinfo )
{
- TIFFClientInfoLink *link = tif->tif_clientinfo;
+ TIFFClientInfoLink *link = tif->tif_clientinfo;
- tif->tif_clientinfo = link->next;
- _TIFFfree( link->name );
- _TIFFfree( link );
+ tif->tif_clientinfo = link->next;
+ _TIFFfree( link->name );
+ _TIFFfree( link );
}
if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER))
- _TIFFfree(tif->tif_rawdata);
+ _TIFFfree(tif->tif_rawdata);
if (isMapped(tif))
- TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size);
+ TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size);
/* Clean up custom fields */
- if (tif->tif_nfields > 0)
+ if (tif->tif_nfields > 0)
{
- size_t i;
+ size_t i;
for (i = 0; i < tif->tif_nfields; i++)
{
diff --git a/src/libtiff/tif_codec.c b/src/libtiff/tif_codec.c
index 69bfca8..725aa85 100644
--- a/src/libtiff/tif_codec.c
+++ b/src/libtiff/tif_codec.c
@@ -1,4 +1,4 @@
-/* $Id: tif_codec.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_codec.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -102,12 +102,9 @@ static int
_notConfigured(TIFF* tif)
{
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
- char compression_code[20];
-
- sprintf( compression_code, "%d", tif->tif_dir.td_compression );
+
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%s compression support is not configured",
- c ? c->name : compression_code );
+ "%s compression support is not configured", c->name);
return (0);
}
diff --git a/src/libtiff/tif_color.c b/src/libtiff/tif_color.c
index 704b714..b9c8fc2 100644
--- a/src/libtiff/tif_color.c
+++ b/src/libtiff/tif_color.c
@@ -1,4 +1,4 @@
-/* $Id: tif_color.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_color.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_compress.c b/src/libtiff/tif_compress.c
index 2efc9e2..4e2b4b6 100644
--- a/src/libtiff/tif_compress.c
+++ b/src/libtiff/tif_compress.c
@@ -1,4 +1,4 @@
-/* $Id: tif_compress.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_compress.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -37,13 +37,12 @@ TIFFNoEncode(TIFF* tif, const char* method)
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%s %s encoding is not implemented",
- c->name, method);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s encoding is not implemented",
+ c->name, method);
} else {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Compression scheme %u %s encoding is not implemented",
- tif->tif_dir.td_compression, method);
+ "Compression scheme %u %s encoding is not implemented",
+ tif->tif_dir.td_compression, method);
}
return (-1);
}
@@ -75,13 +74,12 @@ TIFFNoDecode(TIFF* tif, const char* method)
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c)
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%s %s decoding is not implemented",
- c->name, method);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s decoding is not implemented",
+ c->name, method);
else
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Compression scheme %u %s decoding is not implemented",
- tif->tif_dir.td_compression, method);
+ "Compression scheme %u %s decoding is not implemented",
+ tif->tif_dir.td_compression, method);
return (-1);
}
@@ -111,7 +109,7 @@ _TIFFNoSeek(TIFF* tif, uint32 off)
{
(void) off;
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Compression algorithm does not support random access");
+ "Compression algorithm does not support random access");
return (0);
}
@@ -146,7 +144,7 @@ _TIFFSetDefaultCompressionState(TIFF* tif)
tif->tif_cleanup = _TIFFvoid;
tif->tif_defstripsize = _TIFFDefaultStripSize;
tif->tif_deftilesize = _TIFFDefaultTileSize;
- tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW);
+ tif->tif_flags &= ~TIFF_NOBITREV;
}
int
diff --git a/src/libtiff/tif_dir.c b/src/libtiff/tif_dir.c
index 0290bfd..7dc060d 100644
--- a/src/libtiff/tif_dir.c
+++ b/src/libtiff/tif_dir.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dir.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_dir.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -74,37 +74,21 @@ void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n)
static int
setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)
{
-/* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */
-#define EXTRASAMPLE_COREL_UNASSALPHA 999
-
uint16* va;
uint32 i;
*v = va_arg(ap, uint32);
if ((uint16) *v > td->td_samplesperpixel)
- return 0;
+ return (0);
va = va_arg(ap, uint16*);
if (*v > 0 && va == NULL) /* typically missing param */
- return 0;
- for (i = 0; i < *v; i++) {
- if (va[i] > EXTRASAMPLE_UNASSALPHA) {
- /*
- * XXX: Corel Draw is known to produce incorrect
- * ExtraSamples tags which must be patched here if we
- * want to be able to open some of the damaged TIFF
- * files:
- */
- if (va[i] == EXTRASAMPLE_COREL_UNASSALPHA)
- va[i] = EXTRASAMPLE_UNASSALPHA;
- else
- return 0;
- }
- }
+ return (0);
+ for (i = 0; i < *v; i++)
+ if (va[i] > EXTRASAMPLE_UNASSALPHA)
+ return (0);
td->td_extrasamples = (uint16) *v;
_TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
- return 1;
-
-#undef EXTRASAMPLE_COREL_UNASSALPHA
+ return (1);
}
static uint32
@@ -137,7 +121,7 @@ static int
_TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
{
static const char module[] = "_TIFFVSetField";
-
+
TIFFDirectory* td = &tif->tif_dir;
int status = 1;
uint32 v32, i, v;
@@ -208,11 +192,14 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
goto badvalue;
td->td_fillorder = (uint16) v;
break;
+ break;
case TIFFTAG_ORIENTATION:
v = va_arg(ap, uint32);
- if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v)
- goto badvalue;
- else
+ if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
+ TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
+ "Bad value %lu for \"%s\" tag ignored",
+ v, _TIFFFieldWithTag(tif, tag)->field_name);
+ } else
td->td_orientation = (uint16) v;
break;
case TIFFTAG_SAMPLESPERPIXEL:
@@ -358,9 +345,8 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
_TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),
(long) td->td_nsubifd);
} else {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Sorry, cannot nest SubIFDs",
- tif->tif_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: Sorry, cannot nest SubIFDs",
+ tif->tif_name);
status = 0;
}
break;
@@ -388,9 +374,9 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
}
break;
default: {
+ const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
TIFFTagValue *tv;
int tv_size, iCustom;
- const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
/*
* This can happen if multiple images are open with different
@@ -403,9 +389,9 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
*/
if(fip == NULL || fip->field_bit != FIELD_CUSTOM) {
TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Invalid %stag \"%s\" (not supported by codec)",
- tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
- fip ? fip->field_name : "Unknown");
+ "%s: Invalid %stag \"%s\" (not supported by codec)",
+ tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
+ _TIFFFieldWithTag(tif, tag)->field_name);
status = 0;
break;
}
@@ -414,15 +400,16 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
* Find the existing entry for this custom value.
*/
tv = NULL;
- for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) {
- if (td->td_customValues[iCustom].info->field_tag == tag) {
- tv = td->td_customValues + iCustom;
- if (tv->value != NULL) {
- _TIFFfree(tv->value);
- tv->value = NULL;
- }
- break;
- }
+ for(iCustom = 0; iCustom < td->td_customValueCount; iCustom++) {
+ if(td->td_customValues[iCustom].info == fip) {
+ tv = td->td_customValues + iCustom;
+ if(tv->value != NULL)
+ {
+ _TIFFfree(tv->value);
+ tv->value = NULL;
+ }
+ break;
+ }
}
/*
@@ -445,7 +432,7 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
td->td_customValues = new_customValues;
- tv = td->td_customValues + (td->td_customValueCount - 1);
+ tv = td->td_customValues + (td->td_customValueCount-1);
tv->info = fip;
tv->value = NULL;
tv->count = 0;
@@ -481,8 +468,7 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
if (fip->field_type == TIFF_ASCII)
_TIFFsetString((char **)&tv->value, va_arg(ap, char *));
else {
- tv->value = _TIFFCheckMalloc(tif, tv_size, tv->count,
- "Tag Value");
+ tv->value = _TIFFmalloc(tv_size * tv->count);
if (!tv->value) {
status = 0;
goto end;
@@ -585,17 +571,13 @@ end:
va_end(ap);
return (status);
badvalue:
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Bad value %d for \"%s\" tag",
- tif->tif_name, v,
- _TIFFFieldWithTag(tif, tag)->field_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %d for \"%s\"",
+ tif->tif_name, v, _TIFFFieldWithTag(tif, tag)->field_name);
va_end(ap);
return (0);
badvalue32:
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Bad value %u for \"%s\" tag",
- tif->tif_name, v32,
- _TIFFFieldWithTag(tif, tag)->field_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %ld for \"%s\"",
+ tif->tif_name, v32, _TIFFFieldWithTag(tif, tag)->field_name);
va_end(ap);
return (0);
}
@@ -824,22 +806,21 @@ _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
int i;
/*
- * This can happen if multiple images are open with different
- * codecs which have private tags. The global tag information
- * table may then have tags that are valid for one file but not
- * the other. If the client tries to get a tag that is not valid
- * for the image's codec then we'll arrive here.
+ * This can happen if multiple images are open with
+ * different codecs which have private tags. The
+ * global tag information table may then have tags
+ * that are valid for one file but not the other.
+ * If the client tries to get a tag that is not valid
+ * for the image's codec then we'll arrive here.
*/
if( fip == NULL || fip->field_bit != FIELD_CUSTOM )
{
- TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",
- "%s: Invalid %stag \"%s\" "
- "(not supported by codec)",
- tif->tif_name,
- isPseudoTag(tag) ? "pseudo-" : "",
- fip ? fip->field_name : "Unknown");
- ret_val = 0;
- break;
+ TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",
+ "%s: Invalid %stag \"%s\" (not supported by codec)",
+ tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
+ _TIFFFieldWithTag(tif, tag)->field_name);
+ ret_val = 0;
+ break;
}
/*
@@ -1051,7 +1032,7 @@ TIFFDefaultDirectory(TIFF* tif)
size_t tiffFieldInfoCount;
const TIFFFieldInfo *tiffFieldInfo =
- _TIFFGetFieldInfo(&tiffFieldInfoCount);
+ _TIFFGetFieldInfo(&tiffFieldInfoCount);
_TIFFSetupFieldInfo(tif, tiffFieldInfo, tiffFieldInfoCount);
_TIFFmemset(td, 0, sizeof (*td));
@@ -1072,7 +1053,7 @@ TIFFDefaultDirectory(TIFF* tif)
td->td_ycbcrsubsampling[1] = 2;
td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
tif->tif_postdecode = _TIFFNoPostDecode;
- tif->tif_foundfield = NULL;
+ tif->tif_foundfield = NULL;
tif->tif_tagmethods.vsetfield = _TIFFVSetField;
tif->tif_tagmethods.vgetfield = _TIFFVGetField;
tif->tif_tagmethods.printdir = NULL;
@@ -1093,12 +1074,12 @@ TIFFDefaultDirectory(TIFF* tif)
*/
tif->tif_flags &= ~TIFF_DIRTYDIRECT;
- /*
- * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
- * we clear the ISTILED flag when setting up a new directory.
- * Should we also be clearing stuff like INSUBIFD?
- */
- tif->tif_flags &= ~TIFF_ISTILED;
+ /*
+ * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
+ * we clear the ISTILED flag when setting up a new directory.
+ * Should we also be clearing stuff like INSUBIFD?
+ */
+ tif->tif_flags &= ~TIFF_ISTILED;
return (1);
}
@@ -1106,59 +1087,59 @@ TIFFDefaultDirectory(TIFF* tif)
static int
TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
{
- static const char module[] = "TIFFAdvanceDirectory";
- uint16 dircount;
- if (isMapped(tif))
- {
- toff_t poff=*nextdir;
- if (poff+sizeof(uint16) > tif->tif_size)
- {
+ static const char module[] = "TIFFAdvanceDirectory";
+ uint16 dircount;
+ if (isMapped(tif))
+ {
+ toff_t poff=*nextdir;
+ if (poff+sizeof(uint16) > tif->tif_size)
+ {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
- tif->tif_name);
- return (0);
- }
- _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16));
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry);
- if (off != NULL)
- *off = poff;
- if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size)
- {
+ tif->tif_name);
+ return (0);
+ }
+ _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16));
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry);
+ if (off != NULL)
+ *off = poff;
+ if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size)
+ {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
- tif->tif_name);
- return (0);
- }
- _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32));
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabLong(nextdir);
- return (1);
- }
- else
- {
- if (!SeekOK(tif, *nextdir) ||
- !ReadOK(tif, &dircount, sizeof (uint16))) {
+ tif->tif_name);
+ return (0);
+ }
+ _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32));
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabLong(nextdir);
+ return (1);
+ }
+ else
+ {
+ if (!SeekOK(tif, *nextdir) ||
+ !ReadOK(tif, &dircount, sizeof (uint16))) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
- tif->tif_name);
- return (0);
- }
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- if (off != NULL)
- *off = TIFFSeekFile(tif,
- dircount*sizeof (TIFFDirEntry), SEEK_CUR);
- else
- (void) TIFFSeekFile(tif,
- dircount*sizeof (TIFFDirEntry), SEEK_CUR);
- if (!ReadOK(tif, nextdir, sizeof (uint32))) {
+ tif->tif_name);
+ return (0);
+ }
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ if (off != NULL)
+ *off = TIFFSeekFile(tif,
+ dircount*sizeof (TIFFDirEntry), SEEK_CUR);
+ else
+ (void) TIFFSeekFile(tif,
+ dircount*sizeof (TIFFDirEntry), SEEK_CUR);
+ if (!ReadOK(tif, nextdir, sizeof (uint32))) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
- tif->tif_name);
- return (0);
- }
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabLong(nextdir);
- return (1);
- }
+ tif->tif_name);
+ return (0);
+ }
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabLong(nextdir);
+ return (1);
+ }
}
/*
diff --git a/src/libtiff/tif_dir.h b/src/libtiff/tif_dir.h
index bc86d0e..869ecfa 100644
--- a/src/libtiff/tif_dir.h
+++ b/src/libtiff/tif_dir.h
@@ -1,4 +1,4 @@
-/* $Id: tif_dir.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_dir.h,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -38,47 +38,44 @@ typedef struct {
/* bit vector of fields that are set */
unsigned long td_fieldsset[FIELD_SETLONGS];
- uint32 td_imagewidth, td_imagelength, td_imagedepth;
- uint32 td_tilewidth, td_tilelength, td_tiledepth;
- uint32 td_subfiletype;
- uint16 td_bitspersample;
- uint16 td_sampleformat;
- uint16 td_compression;
- uint16 td_photometric;
- uint16 td_threshholding;
- uint16 td_fillorder;
- uint16 td_orientation;
- uint16 td_samplesperpixel;
- uint32 td_rowsperstrip;
- uint16 td_minsamplevalue, td_maxsamplevalue;
- double td_sminsamplevalue, td_smaxsamplevalue;
- float td_xresolution, td_yresolution;
- uint16 td_resolutionunit;
- uint16 td_planarconfig;
- float td_xposition, td_yposition;
- uint16 td_pagenumber[2];
- uint16* td_colormap[3];
- uint16 td_halftonehints[2];
- uint16 td_extrasamples;
- uint16* td_sampleinfo;
- /* 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 */
- int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
- uint16 td_nsubifd;
- uint32* td_subifd;
+ uint32 td_imagewidth, td_imagelength, td_imagedepth;
+ uint32 td_tilewidth, td_tilelength, td_tiledepth;
+ uint32 td_subfiletype;
+ uint16 td_bitspersample;
+ uint16 td_sampleformat;
+ uint16 td_compression;
+ uint16 td_photometric;
+ uint16 td_threshholding;
+ uint16 td_fillorder;
+ uint16 td_orientation;
+ uint16 td_samplesperpixel;
+ uint32 td_rowsperstrip;
+ uint16 td_minsamplevalue, td_maxsamplevalue;
+ double td_sminsamplevalue, td_smaxsamplevalue;
+ float td_xresolution, td_yresolution;
+ uint16 td_resolutionunit;
+ uint16 td_planarconfig;
+ float td_xposition, td_yposition;
+ uint16 td_pagenumber[2];
+ uint16* td_colormap[3];
+ uint16 td_halftonehints[2];
+ uint16 td_extrasamples;
+ uint16* td_sampleinfo;
+ tstrip_t td_stripsperimage;
+ tstrip_t td_nstrips; /* size of offset & bytecount arrays */
+ uint32* td_stripoffset;
+ uint32* td_stripbytecount;
+ int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
+ uint16 td_nsubifd;
+ uint32* td_subifd;
/* YCbCr parameters */
- uint16 td_ycbcrsubsampling[2];
- uint16 td_ycbcrpositioning;
+ uint16 td_ycbcrsubsampling[2];
+ uint16 td_ycbcrpositioning;
/* Colorimetry parameters */
- uint16* td_transferfunction[3];
+ uint16* td_transferfunction[3];
/* CMYK parameters */
- int td_inknameslen;
- char* td_inknames;
+ int td_inknameslen;
+ char* td_inknames;
int td_customValueCount;
TIFFTagValue *td_customValues;
@@ -180,7 +177,6 @@ extern "C" {
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,
@@ -189,6 +185,7 @@ extern const TIFFFieldInfo* _TIFFFindOrRegisterFieldInfo( TIFF *tif,
extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag,
TIFFDataType dt );
+#define _TIFFMergeFieldInfo TIFFMergeFieldInfo
#define _TIFFFindFieldInfo TIFFFindFieldInfo
#define _TIFFFindFieldInfoByName TIFFFindFieldInfoByName
#define _TIFFFieldWithTag TIFFFieldWithTag
diff --git a/src/libtiff/tif_dirinfo.c b/src/libtiff/tif_dirinfo.c
index 440cf32..17a220a 100644
--- a/src/libtiff/tif_dirinfo.c
+++ b/src/libtiff/tif_dirinfo.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dirinfo.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_dirinfo.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -31,7 +31,6 @@
*/
#include "tiffiop.h"
#include <stdlib.h>
-#include <string.h>
/*
* NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
@@ -450,8 +449,6 @@ exifFieldInfo[] = {
1, 0, "SubSecTimeDigitized" },
{ EXIFTAG_FLASHPIXVERSION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM,
1, 0, "FlashpixVersion" },
- { EXIFTAG_COLORSPACE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
- 1, 0, "ColorSpace" },
{ EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_LONG, FIELD_CUSTOM,
1, 0, "PixelXDimension" },
{ EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
@@ -545,11 +542,7 @@ _TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n)
_TIFFfree(tif->tif_fieldinfo);
tif->tif_nfields = 0;
}
- if (!_TIFFMergeFieldInfo(tif, info, n))
- {
- TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFieldInfo",
- "Setting up field info failed");
- }
+ _TIFFMergeFieldInfo(tif, info, n);
}
static int
@@ -559,10 +552,9 @@ tagCompare(const void* a, const void* b)
const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
/* NB: be careful of return values for 16-bit platforms */
if (ta->field_tag != tb->field_tag)
- return (int)ta->field_tag - (int)tb->field_tag;
+ return (ta->field_tag < tb->field_tag ? -1 : 1);
else
- return (ta->field_type == TIFF_ANY) ?
- 0 : ((int)tb->field_type - (int)ta->field_type);
+ return ((int)tb->field_type - (int)ta->field_type);
}
static int
@@ -570,30 +562,13 @@ tagNameCompare(const void* a, const void* b)
{
const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
- int ret = strcmp(ta->field_name, tb->field_name);
- if (ret)
- return ret;
- else
- return (ta->field_type == TIFF_ANY) ?
- 0 : ((int)tb->field_type - (int)ta->field_type);
+ return strcmp(ta->field_name, tb->field_name);
}
void
-TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
-{
- if (_TIFFMergeFieldInfo(tif, info, n) < 0)
- {
- TIFFErrorExt(tif->tif_clientdata, "TIFFMergeFieldInfo",
- "Merging block of %d fields failed", n);
- }
-}
-
-int
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
- static const char module[] = "_TIFFMergeFieldInfo";
- static const char reason[] = "for field info array";
TIFFFieldInfo** tp;
int i;
@@ -601,37 +576,20 @@ _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
if (tif->tif_nfields > 0) {
tif->tif_fieldinfo = (TIFFFieldInfo**)
- _TIFFCheckRealloc(tif, tif->tif_fieldinfo,
- (tif->tif_nfields + n),
- sizeof (TIFFFieldInfo*), reason);
+ _TIFFrealloc(tif->tif_fieldinfo,
+ (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
} else {
tif->tif_fieldinfo = (TIFFFieldInfo**)
- _TIFFCheckMalloc(tif, n, sizeof (TIFFFieldInfo*),
- reason);
- }
- if (!tif->tif_fieldinfo) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Failed to allocate field info array");
- return 0;
+ _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
}
+ assert(tif->tif_fieldinfo != NULL);
tp = tif->tif_fieldinfo + tif->tif_nfields;
for (i = 0; i < n; i++)
- {
- const TIFFFieldInfo *fip =
- _TIFFFindFieldInfo(tif, info[i].field_tag, info[i].field_type);
-
- /* only add definitions that aren't already present */
- if (!fip) {
- *tp++ = (TIFFFieldInfo*) (info + i);
- tif->tif_nfields++;
- }
- }
+ *tp++ = (TIFFFieldInfo*) (info + i); /* XXX */
/* Sort the field info by tag number */
- qsort(tif->tif_fieldinfo, tif->tif_nfields,
+ qsort(tif->tif_fieldinfo, tif->tif_nfields += n,
sizeof (TIFFFieldInfo*), tagCompare);
-
- return n;
}
void
@@ -746,58 +704,67 @@ _TIFFSampleToTagType(TIFF* tif)
const TIFFFieldInfo*
_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
{
- TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
- TIFFFieldInfo* pkey = &key;
- const TIFFFieldInfo **ret;
+ int i, n;
if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
(dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
- return tif->tif_foundfield;
-
- /* If we are invoked with no field information, then just return. */
- if ( !tif->tif_fieldinfo ) {
- return NULL;
- }
-
+ return (tif->tif_foundfield);
/* NB: use sorted search (e.g. binary search) */
- key.field_tag = tag;
- key.field_type = dt;
-
- ret = (const TIFFFieldInfo **) bsearch(&pkey,
- tif->tif_fieldinfo,
- tif->tif_nfields,
- sizeof(TIFFFieldInfo *),
- tagCompare);
- return tif->tif_foundfield = (ret ? *ret : NULL);
+ if(dt != TIFF_ANY) {
+ TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
+ TIFFFieldInfo* pkey = &key;
+ const TIFFFieldInfo **ret;
+
+ key.field_tag = tag;
+ key.field_type = dt;
+
+ ret = (const TIFFFieldInfo **) bsearch(&pkey,
+ tif->tif_fieldinfo,
+ tif->tif_nfields,
+ sizeof(TIFFFieldInfo *),
+ tagCompare);
+ return (ret) ? (*ret) : NULL;
+ } else for (i = 0, n = tif->tif_nfields; i < n; i++) {
+ const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
+ if (fip->field_tag == tag &&
+ (dt == TIFF_ANY || fip->field_type == dt))
+ return (tif->tif_foundfield = fip);
+ }
+ return ((const TIFFFieldInfo *)0);
}
const TIFFFieldInfo*
_TIFFFindFieldInfoByName(TIFF* tif, const char *field_name, TIFFDataType dt)
{
- TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
- TIFFFieldInfo* pkey = &key;
- const TIFFFieldInfo **ret;
+ int i, n;
if (tif->tif_foundfield
&& streq(tif->tif_foundfield->field_name, field_name)
&& (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
return (tif->tif_foundfield);
-
- /* If we are invoked with no field information, then just return. */
- if ( !tif->tif_fieldinfo ) {
- return NULL;
- }
-
/* NB: use sorted search (e.g. binary search) */
- key.field_name = (char *)field_name;
- key.field_type = dt;
-
- ret = (const TIFFFieldInfo **) lfind(&pkey,
- tif->tif_fieldinfo,
- &tif->tif_nfields,
- sizeof(TIFFFieldInfo *),
- tagNameCompare);
- return tif->tif_foundfield = (ret ? *ret : NULL);
+ if(dt != TIFF_ANY) {
+ TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
+ TIFFFieldInfo* pkey = &key;
+ const TIFFFieldInfo **ret;
+
+ key.field_name = (char *)field_name;
+ key.field_type = dt;
+
+ ret = (const TIFFFieldInfo **) lfind(&pkey,
+ tif->tif_fieldinfo,
+ &tif->tif_nfields,
+ sizeof(TIFFFieldInfo *),
+ tagNameCompare);
+ return (ret) ? (*ret) : NULL;
+ } else
+ for (i = 0, n = tif->tif_nfields; i < n; i++) {
+ const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
+ if (streq(fip->field_name, field_name) &&
+ (dt == TIFF_ANY || fip->field_type == dt))
+ return (tif->tif_foundfield = fip);
+ }
+ return ((const TIFFFieldInfo *)0);
}
const TIFFFieldInfo*
@@ -806,8 +773,8 @@ _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
if (!fip) {
TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
- "Internal error, unknown tag 0x%x",
- (unsigned int) tag);
+ "Internal error, unknown tag 0x%x",
+ (unsigned int) tag);
assert(fip != NULL);
/*NOTREACHED*/
}
@@ -821,7 +788,7 @@ _TIFFFieldWithName(TIFF* tif, const char *field_name)
_TIFFFindFieldInfoByName(tif, field_name, TIFF_ANY);
if (!fip) {
TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
- "Internal error, unknown tag %s", field_name);
+ "Internal error, unknown tag %s", field_name);
assert(fip != NULL);
/*NOTREACHED*/
}
@@ -838,8 +805,7 @@ _TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
if( fld == NULL )
{
fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
- if (!_TIFFMergeFieldInfo(tif, fld, 1))
- return NULL;
+ _TIFFMergeFieldInfo( tif, fld, 1 );
}
return fld;
@@ -857,8 +823,8 @@ _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
_TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
fld->field_tag = tag;
- fld->field_readcount = TIFF_VARIABLE2;
- fld->field_writecount = TIFF_VARIABLE2;
+ fld->field_readcount = TIFF_VARIABLE;
+ fld->field_writecount = TIFF_VARIABLE;
fld->field_type = field_type;
fld->field_bit = FIELD_CUSTOM;
fld->field_oktochange = TRUE;
@@ -869,8 +835,7 @@ _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
return NULL;
}
- /*
- * note that this name is a special sign to TIFFClose() and
+ /* note that this name is a special sign to TIFFClose() and
* _TIFFSetupFieldInfo() to free the field
*/
sprintf(fld->field_name, "Tag %d", (int) tag);
diff --git a/src/libtiff/tif_dirread.c b/src/libtiff/tif_dirread.c
index 4dc0f67..567af7f 100644
--- a/src/libtiff/tif_dirread.c
+++ b/src/libtiff/tif_dirread.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dirread.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_dirread.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -41,13 +41,9 @@ extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*);
extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*);
#endif
-static TIFFDirEntry* TIFFReadDirectoryFind(TIFFDirEntry* dir,
- uint16 dircount, uint16 tagid);
static int EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);
static void MissingRequired(TIFF*, const char*);
-static int TIFFCheckDirOffset(TIFF*, toff_t);
static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
-static uint16 TIFFFetchDirectory(TIFF*, toff_t, TIFFDirEntry**, toff_t *);
static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
static float TIFFFetchRational(TIFF*, TIFFDirEntry*);
@@ -58,7 +54,6 @@ static int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);
static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
static int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
-static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*);
static float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
static int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*);
@@ -67,8 +62,9 @@ static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
static void ChopUpSingleUncompressedStrip(TIFF*);
/*
- * Read the next TIFF directory from a file and convert it to the internal
- * format. We read directories sequentially.
+ * Read the next TIFF directory from a file
+ * and convert it to the internal format.
+ * We read directories sequentially.
*/
int
TIFFReadDirectory(TIFF* tif)
@@ -83,27 +79,105 @@ TIFFReadDirectory(TIFF* tif)
const TIFFFieldInfo* fip;
size_t fix;
uint16 dircount;
- int diroutoforderwarning = 0, compressionknown = 0;
+ toff_t nextdiroff;
+ int diroutoforderwarning = 0;
+ toff_t* new_dirlist;
tif->tif_diroff = tif->tif_nextdiroff;
+ if (tif->tif_diroff == 0) /* no more directories */
+ return (0);
+
/*
- * Check whether we have the last offset or bad offset (IFD looping).
+ * XXX: Trick to prevent IFD looping. The one can create TIFF file
+ * with looped directory pointers. We will maintain a list of already
+ * seen directories and check every IFD offset against this list.
*/
- if (!TIFFCheckDirOffset(tif, tif->tif_nextdiroff))
- return 0;
+ for (n = 0; n < tif->tif_dirnumber; n++) {
+ if (tif->tif_dirlist[n] == tif->tif_diroff)
+ return (0);
+ }
+ tif->tif_dirnumber++;
+ new_dirlist = (toff_t *)_TIFFrealloc(tif->tif_dirlist,
+ tif->tif_dirnumber * sizeof(toff_t));
+ if (!new_dirlist) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Failed to allocate space for IFD list",
+ tif->tif_name);
+ return (0);
+ }
+ tif->tif_dirlist = new_dirlist;
+ tif->tif_dirlist[tif->tif_dirnumber - 1] = tif->tif_diroff;
+
/*
* Cleanup any previous compression state.
*/
(*tif->tif_cleanup)(tif);
tif->tif_curdir++;
- dircount = TIFFFetchDirectory(tif, tif->tif_nextdiroff,
- &dir, &tif->tif_nextdiroff);
- if (!dircount) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Failed to read directory at offset %u",
- tif->tif_name, tif->tif_nextdiroff);
- return 0;
+ nextdiroff = 0;
+ if (!isMapped(tif)) {
+ if (!SeekOK(tif, tif->tif_diroff)) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Seek error accessing TIFF directory",
+ tif->tif_name);
+ return (0);
+ }
+ if (!ReadOK(tif, &dircount, sizeof (uint16))) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory count",
+ tif->tif_name);
+ return (0);
+ }
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
+ sizeof (TIFFDirEntry),
+ "to read TIFF directory");
+ if (dir == NULL)
+ return (0);
+ if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%.100s: Can not read TIFF directory",
+ tif->tif_name);
+ goto bad;
+ }
+ /*
+ * Read offset to next directory for sequential scans.
+ */
+ (void) ReadOK(tif, &nextdiroff, sizeof (uint32));
+ } else {
+ toff_t off = tif->tif_diroff;
+
+ if (off + sizeof (uint16) > tif->tif_size) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory count",
+ tif->tif_name);
+ return (0);
+ } else
+ _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
+ off += sizeof (uint16);
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
+ sizeof (TIFFDirEntry),
+ "to read TIFF directory");
+ if (dir == NULL)
+ return (0);
+ if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory",
+ tif->tif_name);
+ goto bad;
+ } else {
+ _TIFFmemcpy(dir, tif->tif_base + off,
+ dircount*sizeof (TIFFDirEntry));
+ }
+ off += dircount* sizeof (TIFFDirEntry);
+ if (off + sizeof (uint32) <= tif->tif_size)
+ _TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));
}
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabLong(&nextdiroff);
+ tif->tif_nextdiroff = nextdiroff;
tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */
/*
@@ -142,7 +216,7 @@ TIFFReadDirectory(TIFF* tif)
*
* It sure would have been nice if Aldus had really thought
* this stuff through carefully.
- */
+ */
for (dp = dir, n = dircount; n > 0; n--, dp++) {
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
@@ -162,7 +236,7 @@ TIFFReadDirectory(TIFF* tif)
if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE)
continue;
-
+
/*
* Silicon Beach (at least) writes unordered
* directory tags (violating the spec). Handle
@@ -172,13 +246,13 @@ TIFFReadDirectory(TIFF* tif)
if (!diroutoforderwarning) {
TIFFWarningExt(tif->tif_clientdata, module,
"%s: invalid TIFF directory; tags are not sorted in ascending order",
- tif->tif_name);
+ tif->tif_name);
diroutoforderwarning = 1;
}
fix = 0; /* O(n^2) */
}
while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
+ tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
fix++;
if (fix >= tif->tif_nfields ||
tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
@@ -188,25 +262,18 @@ TIFFReadDirectory(TIFF* tif)
"%s: unknown field with tag %d (0x%x) encountered",
tif->tif_name,
dp->tdir_tag,
- dp->tdir_tag);
+ dp->tdir_tag,
+ dp->tdir_type);
- if (!_TIFFMergeFieldInfo(tif,
- _TIFFCreateAnonFieldInfo(tif,
+ TIFFMergeFieldInfo(tif,
+ _TIFFCreateAnonFieldInfo(tif,
dp->tdir_tag,
(TIFFDataType) dp->tdir_type),
- 1))
- {
- TIFFWarningExt(tif->tif_clientdata,
- module,
- "Registering anonymous field with tag %d (0x%x) failed",
- dp->tdir_tag,
- dp->tdir_tag);
- goto ignore;
- }
- fix = 0;
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
+ 1 );
+ fix = 0;
+ while (fix < tif->tif_nfields &&
+ tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
+ fix++;
}
/*
* Null out old tags that we ignore.
@@ -221,10 +288,10 @@ TIFFReadDirectory(TIFF* tif)
*/
fip = tif->tif_fieldinfo[fix];
while (dp->tdir_type != (unsigned short) fip->field_type
- && fix < tif->tif_nfields) {
+ && fix < tif->tif_nfields) {
if (fip->field_type == TIFF_ANY) /* wildcard */
break;
- fip = tif->tif_fieldinfo[++fix];
+ fip = tif->tif_fieldinfo[++fix];
if (fix >= tif->tif_nfields ||
fip->field_tag != dp->tdir_tag) {
TIFFWarningExt(tif->tif_clientdata, module,
@@ -259,8 +326,6 @@ TIFFReadDirectory(TIFF* tif)
dp->tdir_type, dp->tdir_offset);
if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v))
goto bad;
- else
- compressionknown = 1;
break;
/* XXX: workaround for broken TIFFs */
} else if (dp->tdir_type == TIFF_LONG) {
@@ -296,30 +361,6 @@ TIFFReadDirectory(TIFF* tif)
}
}
- /*
- * XXX: OJPEG hack.
- * If a) compression is OJPEG, b) planarconfig tag says it's separate,
- * c) strip offsets/bytecounts tag are both present and
- * d) both contain exactly one value, then we consistently find
- * that the buggy implementation of the buggy compression scheme
- * matches contig planarconfig best. So we 'fix-up' the tag here
- */
- if ((td->td_compression==COMPRESSION_OJPEG) &&
- (td->td_planarconfig==PLANARCONFIG_SEPARATE)) {
- dp = TIFFReadDirectoryFind(dir,dircount,TIFFTAG_STRIPOFFSETS);
- if ((dp!=0) && (dp->tdir_count==1)) {
- dp = TIFFReadDirectoryFind(dir, dircount,
- TIFFTAG_STRIPBYTECOUNTS);
- if ((dp!=0) && (dp->tdir_count==1)) {
- td->td_planarconfig=PLANARCONFIG_CONTIG;
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "Planarconfig tag value assumed incorrect, "
- "assuming data is contig instead of chunky");
- }
- }
- }
-
/*
* Allocate directory structure and setup defaults.
*/
@@ -328,7 +369,7 @@ TIFFReadDirectory(TIFF* tif)
goto bad;
}
/*
- * Setup appropriate structures (by strip or by tile)
+ * Setup appropriate structures (by strip or by tile)
*/
if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
td->td_nstrips = TIFFNumberOfStrips(tif);
@@ -350,23 +391,9 @@ TIFFReadDirectory(TIFF* tif)
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
td->td_stripsperimage /= td->td_samplesperpixel;
if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
- if ((td->td_compression==COMPRESSION_OJPEG) &&
- (isTiled(tif)==0) &&
- (td->td_nstrips==1)) {
- /*
- * XXX: OJPEG hack.
- * If a) compression is OJPEG, b) it's not a tiled TIFF,
- * and c) the number of strips is 1,
- * then we tolerate the absence of stripoffsets tag,
- * because, presumably, all required data is in the
- * JpegInterchangeFormat stream.
- */
- TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
- } else {
- MissingRequired(tif,
+ MissingRequired(tif,
isTiled(tif) ? "TileOffsets" : "StripOffsets");
- goto bad;
- }
+ goto bad;
}
/*
@@ -387,11 +414,11 @@ TIFFReadDirectory(TIFF* tif)
* one value per sample. Because of this, we
* accept the tag if one value is supplied.
*
- * The MinSampleValue, MaxSampleValue, BitsPerSample
- * DataType and SampleFormat tags are supposed to be
- * written as one value/sample, but some vendors
- * incorrectly write one value only -- so we accept
- * that as well (yech). Other vendors write correct
+ * The MinSampleValue, MaxSampleValue, BitsPerSample
+ * DataType and SampleFormat tags are supposed to be
+ * written as one value/sample, but some vendors
+ * incorrectly write one value only -- so we accept
+ * that as well (yech). Other vendors write correct
* value for NumberOfSamples, but incorrect one for
* BitsPerSample and friends, and we will read this
* too.
@@ -501,69 +528,6 @@ TIFFReadDirectory(TIFF* tif)
break;
}
}
- /*
- * OJPEG hack:
- * - If a) compression is OJPEG, and b) photometric tag is missing,
- * then we consistently find that photometric should be YCbCr
- * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
- * then we consistently find that the buggy implementation of the
- * buggy compression scheme matches photometric YCbCr instead.
- * - If a) compression is OJPEG, and b) bitspersample tag is missing,
- * then we consistently find bitspersample should be 8.
- * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
- * and c) photometric is RGB or YCbCr, then we consistently find
- * samplesperpixel should be 3
- * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
- * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
- * find samplesperpixel should be 3
- */
- if (td->td_compression==COMPRESSION_OJPEG)
- {
- if (!TIFFFieldSet(tif,FIELD_PHOTOMETRIC))
- {
- TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory",
- "Photometric tag is missing, assuming data is YCbCr");
- if (!TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_YCBCR))
- goto bad;
- }
- else if (td->td_photometric==PHOTOMETRIC_RGB)
- {
- td->td_photometric=PHOTOMETRIC_YCBCR;
- TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory",
- "Photometric tag value assumed incorrect, "
- "assuming data is YCbCr instead of RGB");
- }
- if (!TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
- {
- TIFFWarningExt(tif->tif_clientdata,"TIFFReadDirectory",
- "BitsPerSample tag is missing, assuming 8 bits per sample");
- if (!TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,8))
- goto bad;
- }
- if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
- {
- if ((td->td_photometric==PHOTOMETRIC_RGB)
- || (td->td_photometric==PHOTOMETRIC_YCBCR))
- {
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "SamplesPerPixel tag is missing, "
- "assuming correct SamplesPerPixel value is 3");
- if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
- goto bad;
- }
- else if ((td->td_photometric==PHOTOMETRIC_MINISWHITE)
- || (td->td_photometric==PHOTOMETRIC_MINISBLACK))
- {
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "SamplesPerPixel tag is missing, "
- "assuming correct SamplesPerPixel value is 1");
- if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1))
- goto bad;
- }
- }
- }
/*
* Verify Palette image has a Colormap.
*/
@@ -573,90 +537,76 @@ TIFFReadDirectory(TIFF* tif)
goto bad;
}
/*
- * OJPEG hack:
- * We do no further messing with strip/tile offsets/bytecounts in OJPEG
- * TIFFs
+ * Attempt to deal with a missing StripByteCounts tag.
*/
- if (td->td_compression!=COMPRESSION_OJPEG)
- {
+ if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
/*
- * Attempt to deal with a missing StripByteCounts tag.
+ * Some manufacturers violate the spec by not giving
+ * the size of the strips. In this case, assume there
+ * is one uncompressed strip of data.
*/
- if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
- /*
- * Some manufacturers violate the spec by not giving
- * the size of the strips. In this case, assume there
- * is one uncompressed strip of data.
- */
- if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
- td->td_nstrips > 1) ||
- (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
- td->td_nstrips != td->td_samplesperpixel)) {
- MissingRequired(tif, "StripByteCounts");
- goto bad;
- }
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: TIFF directory is missing required "
- "\"%s\" field, calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if (EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
+ if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
+ td->td_nstrips > 1) ||
+ (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
+ td->td_nstrips != td->td_samplesperpixel)) {
+ MissingRequired(tif, "StripByteCounts");
+ goto bad;
+ }
+ TIFFWarningExt(tif->tif_clientdata, module,
+ "%s: TIFF directory is missing required "
+ "\"%s\" field, calculating from imagelength",
+ tif->tif_name,
+ _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
+ if (EstimateStripByteCounts(tif, dir, dircount) < 0)
+ goto bad;
+/*
+ * Assume we have wrong StripByteCount value (in case of single strip) in
+ * following cases:
+ * - it is equal to zero along with StripOffset;
+ * - it is larger than file itself (in case of uncompressed image);
+ * - it is smaller than the size of the bytes per row multiplied on the
+ * number of rows. The last case should not be checked in the case of
+ * writing new image, because we may do not know the exact strip size
+ * until the whole image will be written and directory dumped out.
+ */
+#define BYTECOUNTLOOKSBAD \
+ ( (td->td_stripbytecount[0] == 0 && td->td_stripoffset[0] != 0) || \
+ (td->td_compression == COMPRESSION_NONE && \
+ td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]) || \
+ (tif->tif_mode == O_RDONLY && \
+ td->td_compression == COMPRESSION_NONE && \
+ td->td_stripbytecount[0] < TIFFScanlineSize(tif) * td->td_imagelength) )
+
+ } else if (td->td_nstrips == 1
+ && td->td_stripoffset[0] != 0
+ && BYTECOUNTLOOKSBAD) {
/*
- * Assume we have wrong StripByteCount value (in case
- * of single strip) in following cases:
- * - it is equal to zero along with StripOffset;
- * - it is larger than file itself (in case of uncompressed
- * image);
- * - it is smaller than the size of the bytes per row
- * multiplied on the number of rows. The last case should
- * not be checked in the case of writing new image,
- * because we may do not know the exact strip size
- * until the whole image will be written and directory
- * dumped out.
+ * XXX: Plexus (and others) sometimes give a value of zero for
+ * a tag when they don't know what the correct value is! Try
+ * and handle the simple case of estimating the size of a one
+ * strip image.
*/
- #define BYTECOUNTLOOKSBAD \
- ( (td->td_stripbytecount[0] == 0 && td->td_stripoffset[0] != 0) || \
- (td->td_compression == COMPRESSION_NONE && \
- td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]) || \
- (tif->tif_mode == O_RDONLY && \
- td->td_compression == COMPRESSION_NONE && \
- td->td_stripbytecount[0] < TIFFScanlineSize(tif) * td->td_imagelength) )
-
- } else if (td->td_nstrips == 1
- && td->td_stripoffset[0] != 0
- && BYTECOUNTLOOKSBAD) {
- /*
- * XXX: Plexus (and others) sometimes give a value of
- * zero for a tag when they don't know what the
- * correct value is! Try and handle the simple case
- * of estimating the size of a one strip image.
- */
- TIFFWarningExt(tif->tif_clientdata, module,
+ TIFFWarningExt(tif->tif_clientdata, module,
"%s: Bogus \"%s\" field, ignoring and calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if(EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
- } else if (td->td_planarconfig == PLANARCONFIG_CONTIG
- && td->td_nstrips > 2
- && td->td_compression == COMPRESSION_NONE
- && td->td_stripbytecount[0] != td->td_stripbytecount[1]
- && td->td_stripbytecount[0] != 0
- && td->td_stripbytecount[1] != 0 ) {
- /*
- * XXX: Some vendors fill StripByteCount array with
- * absolutely wrong values (it can be equal to
- * StripOffset array, for example). Catch this case
- * here.
- */
- TIFFWarningExt(tif->tif_clientdata, module,
+ tif->tif_name,
+ _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
+ if(EstimateStripByteCounts(tif, dir, dircount) < 0)
+ goto bad;
+ } else if (td->td_planarconfig == PLANARCONFIG_CONTIG
+ && td->td_nstrips > 2
+ && td->td_compression == COMPRESSION_NONE
+ && td->td_stripbytecount[0] != td->td_stripbytecount[1]) {
+ /*
+ * XXX: Some vendors fill StripByteCount array with absolutely
+ * wrong values (it can be equal to StripOffset array, for
+ * example). Catch this case here.
+ */
+ TIFFWarningExt(tif->tif_clientdata, module,
"%s: Wrong \"%s\" field, ignoring and calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if (EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
- }
+ tif->tif_name,
+ _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
+ if (EstimateStripByteCounts(tif, dir, dircount) < 0)
+ goto bad;
}
if (dir) {
_TIFFfree((char *)dir);
@@ -688,15 +638,15 @@ TIFFReadDirectory(TIFF* tif)
if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
- /*
- * Some manufacturers make life difficult by writing
+ /*
+ * Some manufacturers make life difficult by writing
* large amounts of uncompressed data as a single strip.
* This is contrary to the recommendations of the spec.
- * The following makes an attempt at breaking such images
+ * The following makes an attempt at breaking such images
* into strips closer to the recommended 8k bytes. A
* side effect, however, is that the RowsPerStrip tag
* value may be changed.
- */
+ */
if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE &&
(tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP)
ChopUpSingleUncompressedStrip(tif);
@@ -712,25 +662,22 @@ TIFFReadDirectory(TIFF* tif)
tif->tif_scanlinesize = TIFFScanlineSize(tif);
if (!tif->tif_scanlinesize) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero scanline size",
- tif->tif_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero scanline size",
+ tif->tif_name);
return (0);
}
if (isTiled(tif)) {
tif->tif_tilesize = TIFFTileSize(tif);
if (!tif->tif_tilesize) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero tile size",
- tif->tif_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero tile size",
+ tif->tif_name);
return (0);
}
} else {
if (!TIFFStripSize(tif)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero strip size",
- tif->tif_name);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero strip size",
+ tif->tif_name);
return (0);
}
}
@@ -741,20 +688,7 @@ bad:
return (0);
}
-static TIFFDirEntry*
-TIFFReadDirectoryFind(TIFFDirEntry* dir, uint16 dircount, uint16 tagid)
-{
- TIFFDirEntry* m;
- uint16 n;
- for (m=dir, n=0; n<dircount; m++, n++)
- {
- if (m->tdir_tag==tagid)
- return(m);
- }
- return(0);
-}
-
-/*
+/*
* Read custom directory from the arbitarry offset.
* The code is very similar to TIFFReadDirectory().
*/
@@ -772,16 +706,64 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff,
_TIFFSetupFieldInfo(tif, info, n);
- dircount = TIFFFetchDirectory(tif, diroff, &dir, NULL);
- if (!dircount) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Failed to read custom directory at offset %u",
- tif->tif_name, diroff);
- return 0;
+ tif->tif_diroff = diroff;
+
+ if (!isMapped(tif)) {
+ if (!SeekOK(tif, diroff)) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Seek error accessing TIFF directory",
+ tif->tif_name);
+ return (0);
+ }
+ if (!ReadOK(tif, &dircount, sizeof (uint16))) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory count",
+ tif->tif_name);
+ return (0);
+ }
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
+ sizeof (TIFFDirEntry),
+ "to read TIFF custom directory");
+ if (dir == NULL)
+ return (0);
+ if (!ReadOK(tif, dir, dircount * sizeof (TIFFDirEntry))) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%.100s: Can not read TIFF directory",
+ tif->tif_name);
+ goto bad;
+ }
+ } else {
+ toff_t off = diroff;
+
+ if (off + sizeof (uint16) > tif->tif_size) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory count",
+ tif->tif_name);
+ return (0);
+ } else
+ _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
+ off += sizeof (uint16);
+ if (tif->tif_flags & TIFF_SWAB)
+ TIFFSwabShort(&dircount);
+ dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
+ sizeof (TIFFDirEntry),
+ "to read TIFF custom directory");
+ if (dir == NULL)
+ return (0);
+ if (off + dircount * sizeof (TIFFDirEntry) > tif->tif_size) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Can not read TIFF directory",
+ tif->tif_name);
+ goto bad;
+ } else {
+ _TIFFmemcpy(dir, tif->tif_base + off,
+ dircount * sizeof (TIFFDirEntry));
+ }
}
TIFFFreeDirectory(tif);
- _TIFFmemset(&tif->tif_dir, 0, sizeof(TIFFDirectory));
fix = 0;
for (dp = dir, i = dircount; i > 0; i--, dp++) {
@@ -802,18 +784,14 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff,
TIFFWarningExt(tif->tif_clientdata, module,
"%s: unknown field with tag %d (0x%x) encountered",
- tif->tif_name, dp->tdir_tag, dp->tdir_tag);
- if (!_TIFFMergeFieldInfo(tif,
- _TIFFCreateAnonFieldInfo(tif,
- dp->tdir_tag,
- (TIFFDataType) dp->tdir_type),
- 1))
- {
- TIFFWarningExt(tif->tif_clientdata, module,
- "Registering anonymous field with tag %d (0x%x) failed",
- dp->tdir_tag, dp->tdir_tag);
- goto ignore;
- }
+ tif->tif_name, dp->tdir_tag, dp->tdir_tag,
+ dp->tdir_type);
+
+ TIFFMergeFieldInfo(tif,
+ _TIFFCreateAnonFieldInfo(tif,
+ dp->tdir_tag,
+ (TIFFDataType)dp->tdir_type),
+ 1);
fix = 0;
while (fix < tif->tif_nfields &&
@@ -858,22 +836,17 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff,
goto ignore;
}
- /*
- * EXIF tags which need to be specifically processed.
- */
- switch (dp->tdir_tag) {
- case EXIFTAG_SUBJECTDISTANCE:
- (void) TIFFFetchSubjectDistance(tif, dp);
- break;
- default:
- (void) TIFFFetchNormalTag(tif, dp);
- break;
- }
+ (void) TIFFFetchNormalTag(tif, dp);
}
if (dir)
_TIFFfree(dir);
return 1;
+
+bad:
+ if (dir)
+ _TIFFfree(dir);
+ return 0;
}
/*
@@ -895,18 +868,15 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
{
static const char module[] = "EstimateStripByteCounts";
- TIFFDirEntry *dp;
- TIFFDirectory *td = &tif->tif_dir;
- uint32 strip;
+ register TIFFDirEntry *dp;
+ register TIFFDirectory *td = &tif->tif_dir;
+ uint16 i;
if (td->td_stripbytecount)
_TIFFfree(td->td_stripbytecount);
td->td_stripbytecount = (uint32*)
_TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint32),
"for \"StripByteCounts\" array");
- if( td->td_stripbytecount == NULL )
- return -1;
-
if (td->td_compression != COMPRESSION_NONE) {
uint32 space = (uint32)(sizeof (TIFFHeader)
+ sizeof (uint16)
@@ -932,8 +902,8 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
space = filesize - space;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
space /= td->td_samplesperpixel;
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = space;
+ for (i = 0; i < td->td_nstrips; i++)
+ td->td_stripbytecount[i] = space;
/*
* This gross hack handles the case were the offset to
* the last strip is past the place where we think the strip
@@ -941,21 +911,16 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
* it's safe to assume that we've overestimated the amount
* of data in the strip and trim this number back accordingly.
*/
- strip--;
- if (((toff_t)(td->td_stripoffset[strip]+
- td->td_stripbytecount[strip])) > filesize)
- td->td_stripbytecount[strip] =
- filesize - td->td_stripoffset[strip];
- } else if (isTiled(tif)) {
- uint32 bytespertile = TIFFTileSize(tif);
-
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = bytespertile;
+ i--;
+ if (((toff_t)(td->td_stripoffset[i]+td->td_stripbytecount[i]))
+ > filesize)
+ td->td_stripbytecount[i] =
+ filesize - td->td_stripoffset[i];
} else {
uint32 rowbytes = TIFFScanlineSize(tif);
uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage;
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = rowbytes * rowsperstrip;
+ for (i = 0; i < td->td_nstrips; i++)
+ td->td_stripbytecount[i] = rowbytes*rowsperstrip;
}
TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
@@ -974,65 +939,23 @@ MissingRequired(TIFF* tif, const char* tagname)
}
/*
- * Check the directory offset against the list of already seen directory
- * offsets. This is a trick to prevent IFD looping. The one can create TIFF
- * file with looped directory pointers. We will maintain a list of already
- * seen directories and check every IFD offset against that list.
- */
-static int
-TIFFCheckDirOffset(TIFF* tif, toff_t diroff)
-{
- uint16 n;
-
- if (diroff == 0) /* no more directories */
- return 0;
-
- for (n = 0; n < tif->tif_dirnumber && tif->tif_dirlist; n++) {
- if (tif->tif_dirlist[n] == diroff)
- return 0;
- }
-
- tif->tif_dirnumber++;
-
- if (tif->tif_dirnumber > tif->tif_dirlistsize) {
- toff_t* new_dirlist;
-
- /*
- * XXX: Reduce memory allocation granularity of the dirlist
- * array.
- */
- new_dirlist = (toff_t *)_TIFFCheckRealloc(tif,
- tif->tif_dirlist,
- tif->tif_dirnumber,
- 2 * sizeof(toff_t),
- "for IFD list");
- if (!new_dirlist)
- return 0;
- tif->tif_dirlistsize = 2 * tif->tif_dirnumber;
- tif->tif_dirlist = new_dirlist;
- }
-
- tif->tif_dirlist[tif->tif_dirnumber - 1] = diroff;
-
- return 1;
-}
-
-/*
- * Check the count field of a directory entry against a known value. The
- * caller is expected to skip/ignore the tag if there is a mismatch.
+ * Check the count field of a directory
+ * entry against a known value. The caller
+ * is expected to skip/ignore the tag if
+ * there is a mismatch.
*/
static int
CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
{
if (count > dir->tdir_count) {
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "incorrect count for field \"%s\" (%u, expecting %u); tag ignored",
+ "incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
dir->tdir_count, count);
return (0);
} else if (count < dir->tdir_count) {
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "incorrect count for field \"%s\" (%u, expecting %u); tag trimmed",
+ "incorrect count for field \"%s\" (%lu, expecting %lu); tag trimmed",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
dir->tdir_count, count);
return (1);
@@ -1040,129 +963,17 @@ CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
return (1);
}
-/*
- * Read IFD structure from the specified offset. If the pointer to
- * nextdiroff variable has been specified, read it too. Function returns a
- * number of fields in the directory or 0 if failed.
- */
-static uint16
-TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir,
- toff_t *nextdiroff)
-{
- static const char module[] = "TIFFFetchDirectory";
-
- TIFFDirEntry *dir;
- uint16 dircount;
-
- assert(pdir);
-
- tif->tif_diroff = diroff;
- if (nextdiroff)
- *nextdiroff = 0;
- if (!isMapped(tif)) {
- if (!SeekOK(tif, tif->tif_diroff)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Seek error accessing TIFF directory",
- tif->tif_name);
- return 0;
- }
- if (!ReadOK(tif, &dircount, sizeof (uint16))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory count",
- tif->tif_name);
- return 0;
- }
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
- sizeof (TIFFDirEntry),
- "to read TIFF directory");
- if (dir == NULL)
- return 0;
- if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%.100s: Can not read TIFF directory",
- tif->tif_name);
- _TIFFfree(dir);
- return 0;
- }
- /*
- * Read offset to next directory for sequential scans if
- * needed.
- */
- if (nextdiroff)
- (void) ReadOK(tif, nextdiroff, sizeof(uint32));
- } else {
- toff_t off = tif->tif_diroff;
-
- /*
- * Check for integer overflow when validating the dir_off,
- * otherwise a very high offset may cause an OOB read and
- * crash the client. Make two comparisons instead of
- *
- * off + sizeof(uint16) > tif->tif_size
- *
- * to avoid overflow.
- */
- if (tif->tif_size < sizeof (uint16) ||
- off > tif->tif_size - sizeof(uint16)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory count",
- tif->tif_name);
- return 0;
- } else {
- _TIFFmemcpy(&dircount, tif->tif_base + off,
- sizeof(uint16));
- }
- off += sizeof (uint16);
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
- sizeof(TIFFDirEntry),
- "to read TIFF directory");
- if (dir == NULL)
- return 0;
- if (off + dircount * sizeof (TIFFDirEntry) > tif->tif_size) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory",
- tif->tif_name);
- _TIFFfree(dir);
- return 0;
- } else {
- _TIFFmemcpy(dir, tif->tif_base + off,
- dircount * sizeof(TIFFDirEntry));
- }
- if (nextdiroff) {
- off += dircount * sizeof (TIFFDirEntry);
- if (off + sizeof (uint32) <= tif->tif_size) {
- _TIFFmemcpy(nextdiroff, tif->tif_base + off,
- sizeof (uint32));
- }
- }
- }
- if (nextdiroff && tif->tif_flags & TIFF_SWAB)
- TIFFSwabLong(nextdiroff);
- *pdir = dir;
- return dircount;
-}
-
/*
* Fetch a contiguous directory item.
*/
static tsize_t
TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
{
- uint32 w = TIFFDataWidth((TIFFDataType) dir->tdir_type);
- /*
- * FIXME: butecount should have tsize_t type, but for now libtiff
- * defines tsize_t as a signed 32-bit integer and we are losing
- * ability to read arrays larger than 2^31 bytes. So we are using
- * uint32 instead of tsize_t here.
- */
- uint32 cc = dir->tdir_count * w;
+ int w = TIFFDataWidth((TIFFDataType) dir->tdir_type);
+ tsize_t cc = dir->tdir_count * w;
/* Check for overflow. */
- if (!dir->tdir_count || !w || cc / w != dir->tdir_count)
+ if (!dir->tdir_count || !w || cc / w != (tsize_t)dir->tdir_count)
goto bad;
if (!isMapped(tif)) {
@@ -1172,9 +983,9 @@ TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
goto bad;
} else {
/* Check for overflow. */
- if (dir->tdir_offset + cc < dir->tdir_offset
- || dir->tdir_offset + cc < cc
- || dir->tdir_offset + cc > tif->tif_size)
+ if ((tsize_t)dir->tdir_offset + cc < (tsize_t)dir->tdir_offset
+ || (tsize_t)dir->tdir_offset + cc < cc
+ || (tsize_t)dir->tdir_offset + cc > (tsize_t)tif->tif_size)
goto bad;
_TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);
}
@@ -1230,7 +1041,7 @@ cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
{
if (denom == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%s: Rational with zero denominator (num = %u)",
+ "%s: Rational with zero denominator (num = %lu)",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);
return (0);
} else {
@@ -1243,8 +1054,9 @@ cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
}
/*
- * Fetch a rational item from the file at offset off and return the value as a
- * floating point number.
+ * Fetch a rational item from the file
+ * at offset off and return the value
+ * as a floating point number.
*/
static float
TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
@@ -1257,8 +1069,9 @@ TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
}
/*
- * Fetch a single floating point value from the offset field and return it as
- * a native float.
+ * Fetch a single floating point value
+ * from the offset field and return it
+ * as a native float.
*/
static float
TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
@@ -1346,18 +1159,6 @@ TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
static int
TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
{
- /*
- * Prevent overflowing the v stack arrays below by performing a sanity
- * check on tdir_count, this should never be greater than two.
- */
- if (dir->tdir_count > 2) {
- TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "unexpected count for field \"%s\", %u, expected 2; ignored",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
- dir->tdir_count);
- return 0;
- }
-
switch (dir->tdir_type) {
case TIFF_BYTE:
case TIFF_SBYTE:
@@ -1426,14 +1227,7 @@ TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
{
if (dir->tdir_count == 1) {
- union
- {
- float f;
- uint32 i;
- } float_union;
-
- float_union.i=dir->tdir_offset;
- v[0]=float_union.f;
+ v[0] = *(float*) &dir->tdir_offset;
TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
return (1);
} else if (TIFFFetchData(tif, dir, (char*) v)) {
@@ -1457,13 +1251,15 @@ TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
}
/*
- * Fetch an array of ANY values. The actual values are returned as doubles
- * which should be able hold all the types. Yes, there really should be an
- * tany_t to avoid this potential non-portability ... Note in particular that
- * we assume that the double return value vector is large enough to read in
- * any fundamental type. We use that vector as a buffer to read in the base
- * type vector and then convert it in place to double (from end to front of
- * course).
+ * Fetch an array of ANY values. The actual values are
+ * returned as doubles which should be able hold all the
+ * types. Yes, there really should be an tany_t to avoid
+ * this potential non-portability ... Note in particular
+ * that we assume that the double return value vector is
+ * large enough to read in any fundamental type. We use
+ * that vector as a buffer to read in the base type vector
+ * and then convert it in place to double (from end
+ * to front of course).
*/
static int
TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)
@@ -1714,10 +1510,10 @@ TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, uint16* pl)
for (i = 1; i < check_count; i++)
if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+ "Cannot handle different per-sample values for field \"%s\"",
+ _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
+ goto bad;
}
*pl = v[0];
status = 1;
@@ -1755,10 +1551,10 @@ TIFFFetchPerSampleLongs(TIFF* tif, TIFFDirEntry* dir, uint32* pl)
check_count = samples;
for (i = 1; i < check_count; i++)
if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+ "Cannot handle different per-sample values for field \"%s\"",
+ _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
+ goto bad;
}
*pl = v[0];
status = 1;
@@ -1795,10 +1591,10 @@ TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
for (i = 1; i < check_count; i++)
if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+ "Cannot handle different per-sample values for field \"%s\"",
+ _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
+ goto bad;
}
*pl = v[0];
status = 1;
@@ -1910,34 +1706,11 @@ TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir)
}
/*
- * Fetch and set the SubjectDistance EXIF tag.
- */
-static int
-TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir)
-{
- uint32 l[2];
- float v;
- int ok = 0;
-
- if (TIFFFetchData(tif, dir, (char *)l)
- && cvtRational(tif, dir, l[0], l[1], &v)) {
- /*
- * XXX: Numerator 0xFFFFFFFF means that we have infinite
- * distance. Indicate that with a negative floating point
- * SubjectDistance value.
- */
- ok = TIFFSetField(tif, dir->tdir_tag,
- (l[0] != 0xFFFFFFFF) ? v : -v);
- }
-
- return ok;
-}
-
-/*
- * Replace a single strip (tile) of uncompressed data by multiple strips
- * (tiles), each approximately STRIP_SIZE_DEFAULT bytes. This is useful for
- * dealing with large images or for dealing with machines with a limited
- * amount memory.
+ * Replace a single strip (tile) of uncompressed data by
+ * multiple strips (tiles), each approximately 8Kbytes.
+ * This is useful for dealing with large images or
+ * for dealing with machines with a limited amount
+ * memory.
*/
static void
ChopUpSingleUncompressedStrip(TIFF* tif)
@@ -1979,8 +1752,8 @@ ChopUpSingleUncompressedStrip(TIFF* tif)
"for chopped \"StripOffsets\" array");
if (newcounts == NULL || newoffsets == NULL) {
/*
- * Unable to allocate new strip information, give up and use
- * the original one strip information.
+ * Unable to allocate new strip information, give
+ * up and use the original one strip information.
*/
if (newcounts != NULL)
_TIFFfree(newcounts);
@@ -1993,7 +1766,7 @@ ChopUpSingleUncompressedStrip(TIFF* tif)
* that reflect the broken-up format.
*/
for (strip = 0; strip < nstrips; strip++) {
- if ((uint32)stripbytes > bytecount)
+ if (stripbytes > (tsize_t) bytecount)
stripbytes = bytecount;
newcounts[strip] = stripbytes;
newoffsets[strip] = offset;
diff --git a/src/libtiff/tif_dirwrite.c b/src/libtiff/tif_dirwrite.c
index fe6107d..5e71e3c 100644
--- a/src/libtiff/tif_dirwrite.c
+++ b/src/libtiff/tif_dirwrite.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dirwrite.c,v 1.4 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_dirwrite.c,v 1.5 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -100,34 +100,31 @@ _TIFFWriteDirectory(TIFF* tif, int done)
*/
if (done)
{
- if (tif->tif_flags & TIFF_POSTENCODE) {
- tif->tif_flags &= ~TIFF_POSTENCODE;
- if (!(*tif->tif_postencode)(tif)) {
- TIFFErrorExt(tif->tif_clientdata,
- tif->tif_name,
+ if (tif->tif_flags & TIFF_POSTENCODE) {
+ tif->tif_flags &= ~TIFF_POSTENCODE;
+ if (!(*tif->tif_postencode)(tif)) {
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error post-encoding before directory write");
- return (0);
- }
- }
- (*tif->tif_close)(tif); /* shutdown encoder */
- /*
- * Flush any data that might have been written
- * by the compression close+cleanup routines.
- */
- if (tif->tif_rawcc > 0
- && (tif->tif_flags & TIFF_BEENWRITING) != 0
- && !TIFFFlushData1(tif)) {
+ return (0);
+ }
+ }
+ (*tif->tif_close)(tif); /* shutdown encoder */
+ /*
+ * Flush any data that might have been written
+ * by the compression close+cleanup routines.
+ */
+ if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error flushing data before directory write");
- return (0);
- }
- if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
- _TIFFfree(tif->tif_rawdata);
- tif->tif_rawdata = NULL;
- tif->tif_rawcc = 0;
- tif->tif_rawdatasize = 0;
- }
- tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
+ "Error flushing data before directory write");
+ return (0);
+ }
+ if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
+ _TIFFfree(tif->tif_rawdata);
+ tif->tif_rawdata = NULL;
+ tif->tif_rawcc = 0;
+ tif->tif_rawdatasize = 0;
+ }
+ tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
}
td = &tif->tif_dir;
@@ -140,12 +137,12 @@ _TIFFWriteDirectory(TIFF* tif, int done)
for (b = 0; b <= FIELD_LAST; b++)
if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
- nfields += td->td_customValueCount;
+ nfields += td->td_customValueCount;
dirsize = nfields * sizeof (TIFFDirEntry);
data = (char*) _TIFFmalloc(dirsize);
if (data == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot write directory, out of space");
+ "Cannot write directory, out of space");
return (0);
}
/*
@@ -179,29 +176,30 @@ _TIFFWriteDirectory(TIFF* tif, int done)
for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
- /*
- * For custom fields, we test to see if the custom field
- * is set or not. For normal fields, we just use the
- * FieldSet test.
- */
- if( fip->field_bit == FIELD_CUSTOM )
- {
- int ci, is_set = FALSE;
+ /*
+ ** For custom fields, we test to see if the custom field
+ ** is set or not. For normal fields, we just use the
+ ** FieldSet test.
+ */
+ if( fip->field_bit == FIELD_CUSTOM )
+ {
+ int ci, is_set = FALSE;
- for( ci = 0; ci < td->td_customValueCount; ci++ )
- is_set |= (td->td_customValues[ci].info == fip);
+ for( ci = 0; ci < td->td_customValueCount; ci++ )
+ is_set |= (td->td_customValues[ci].info == fip);
- if( !is_set )
- continue;
- }
+ if( !is_set )
+ continue;
+ }
else if (!FieldSet(fields, fip->field_bit))
- continue;
+ continue;
- /*
- * Handle other fields.
- */
+
+ /*
+ ** Handle other fields.
+ */
switch (fip->field_bit)
- {
+ {
case FIELD_STRIPOFFSETS:
/*
* We use one field bit for both strip and tile
@@ -236,7 +234,8 @@ _TIFFWriteDirectory(TIFF* tif, int done)
dir->tdir_tag = (uint16) tag;
dir->tdir_type = (uint16) TIFF_LONG;
dir->tdir_count = (uint32) td->td_nstrips;
- if (!TIFFWriteLongArray(tif, dir, td->td_stripbytecount))
+ if (!TIFFWriteLongArray(tif, dir,
+ td->td_stripbytecount))
goto bad;
break;
case FIELD_ROWSPERSTRIP:
@@ -347,8 +346,8 @@ _TIFFWriteDirectory(TIFF* tif, int done)
}
dir++;
- if( fip->field_bit != FIELD_CUSTOM )
- ResetFieldBit(fields, fip->field_bit);
+ if( fip->field_bit != FIELD_CUSTOM )
+ ResetFieldBit(fields, fip->field_bit);
}
/*
@@ -377,18 +376,15 @@ _TIFFWriteDirectory(TIFF* tif, int done)
}
(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
if (!WriteOK(tif, &dircount, sizeof (dircount))) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory count");
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory count");
goto bad;
}
if (!WriteOK(tif, data, dirsize)) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory contents");
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory contents");
goto bad;
}
- if (!WriteOK(tif, &diroff, sizeof (uint32))) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory link");
+ if (!WriteOK(tif, &diroff, sizeof (diroff))) {
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory link");
goto bad;
}
if (done) {
@@ -434,133 +430,6 @@ TIFFCheckpointDirectory(TIFF* tif)
return rc;
}
-static int
-_TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)
-{
- uint16 dircount;
- uint32 nfields;
- tsize_t dirsize;
- char* data;
- TIFFDirEntry* dir;
- TIFFDirectory* td;
- unsigned long b, fields[FIELD_SETLONGS];
- int fi, nfi;
-
- if (tif->tif_mode == O_RDONLY)
- return (1);
-
- td = &tif->tif_dir;
- /*
- * Size the directory so that we can calculate
- * offsets for the data items that aren't kept
- * in-place in each field.
- */
- nfields = 0;
- for (b = 0; b <= FIELD_LAST; b++)
- if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
- nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
- nfields += td->td_customValueCount;
- dirsize = nfields * sizeof (TIFFDirEntry);
- data = (char*) _TIFFmalloc(dirsize);
- if (data == NULL) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot write directory, out of space");
- return (0);
- }
- /*
- * Put the directory at the end of the file.
- */
- tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
- tif->tif_dataoff = (toff_t)(
- tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
- if (tif->tif_dataoff & 1)
- tif->tif_dataoff++;
- (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
- dir = (TIFFDirEntry*) data;
- /*
- * Setup external form of directory
- * entries and write data items.
- */
- _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
-
- for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
- const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
-
- /*
- * For custom fields, we test to see if the custom field
- * is set or not. For normal fields, we just use the
- * FieldSet test.
- */
- if( fip->field_bit == FIELD_CUSTOM )
- {
- int ci, is_set = FALSE;
-
- for( ci = 0; ci < td->td_customValueCount; ci++ )
- is_set |= (td->td_customValues[ci].info == fip);
-
- if( !is_set )
- continue;
- }
- else if (!FieldSet(fields, fip->field_bit))
- continue;
-
- if( fip->field_bit != FIELD_CUSTOM )
- ResetFieldBit(fields, fip->field_bit);
- }
-
- /*
- * Write directory.
- */
- dircount = (uint16) nfields;
- *pdiroff = (uint32) tif->tif_nextdiroff;
- if (tif->tif_flags & TIFF_SWAB) {
- /*
- * The file's byte order is opposite to the
- * native machine architecture. We overwrite
- * the directory information with impunity
- * because it'll be released below after we
- * write it to the file. Note that all the
- * other tag construction routines assume that
- * we do this byte-swapping; i.e. they only
- * byte-swap indirect data.
- */
- for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
- TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
- TIFFSwabArrayOfLong(&dir->tdir_count, 2);
- }
- dircount = (uint16) nfields;
- TIFFSwabShort(&dircount);
- TIFFSwabLong(pdiroff);
- }
- (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
- if (!WriteOK(tif, &dircount, sizeof (dircount))) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory count");
- goto bad;
- }
- if (!WriteOK(tif, data, dirsize)) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory contents");
- goto bad;
- }
- if (!WriteOK(tif, pdiroff, sizeof (uint32))) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing directory link");
- goto bad;
- }
- _TIFFfree(data);
- return (1);
-bad:
- _TIFFfree(data);
- return (0);
-}
-
-int
-TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)
-{
- return _TIFFWriteCustomDirectory(tif, pdiroff);
-}
-
/*
* Process tags that are not special cased.
*/
@@ -712,12 +581,7 @@ TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
{
char* cp;
if (fip->field_passcount)
- {
- if( wc == (uint16) TIFF_VARIABLE2 )
- TIFFGetField(tif, fip->field_tag, &wc2, &cp);
- else
- TIFFGetField(tif, fip->field_tag, &wc, &cp);
- }
+ TIFFGetField(tif, fip->field_tag, &wc, &cp);
else
TIFFGetField(tif, fip->field_tag, &cp);
@@ -922,27 +786,12 @@ TIFFWriteShortTable(TIFF* tif,
static int
TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp)
{
- if (dir->tdir_count <= 4) {
- if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
- dir->tdir_offset = (uint32)cp[0] << 24;
- if (dir->tdir_count >= 2)
- dir->tdir_offset |= (uint32)cp[1] << 16;
- if (dir->tdir_count >= 3)
- dir->tdir_offset |= (uint32)cp[2] << 8;
- if (dir->tdir_count == 4)
- dir->tdir_offset |= cp[3];
- } else {
- dir->tdir_offset = cp[0];
- if (dir->tdir_count >= 2)
- dir->tdir_offset |= (uint32) cp[1] << 8;
- if (dir->tdir_count >= 3)
- dir->tdir_offset |= (uint32) cp[2] << 16;
- if (dir->tdir_count == 4)
- dir->tdir_offset |= (uint32) cp[3] << 24;
- }
- return 1;
+ if (dir->tdir_count > 4) {
+ if (!TIFFWriteData(tif, dir, cp))
+ return (0);
} else
- return TIFFWriteData(tif, dir, cp);
+ _TIFFmemcpy(&dir->tdir_offset, cp, dir->tdir_count);
+ return (1);
}
/*
@@ -954,13 +803,13 @@ TIFFWriteShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
{
if (dir->tdir_count <= 2) {
if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
- dir->tdir_offset = (uint32) v[0] << 16;
+ dir->tdir_offset = (uint32) ((long) v[0] << 16);
if (dir->tdir_count == 2)
dir->tdir_offset |= v[1] & 0xffff;
} else {
dir->tdir_offset = v[0] & 0xffff;
if (dir->tdir_count == 2)
- dir->tdir_offset |= (uint32) v[1] << 16;
+ dir->tdir_offset |= (long) v[1] << 16;
}
return (1);
} else
@@ -1005,11 +854,10 @@ TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
if (fv < 0) {
if (dir->tdir_type == TIFF_RATIONAL) {
- TIFFWarningExt(tif->tif_clientdata,
- tif->tif_name,
+ TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
"\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL",
_TIFFFieldWithTag(tif,dir->tdir_tag)->field_name,
- fv);
+ fv);
fv = 0;
} else
fv = -fv, sign = -1;
@@ -1066,7 +914,7 @@ TIFFWriteAnyArray(TIFF* tif,
w = (char*) _TIFFmalloc(n * TIFFDataWidth(type));
if (w == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "No space to write array");
+ "No space to write array");
return (0);
}
}
@@ -1140,11 +988,7 @@ TIFFWriteAnyArray(TIFF* tif,
}
break;
case TIFF_DOUBLE:
- {
- if( !TIFFWriteDoubleArray(tif, dir, v))
- goto out;
- }
- break;
+ return (TIFFWriteDoubleArray(tif, dir, v));
default:
/* TIFF_NOTYPE */
/* TIFF_ASCII */
@@ -1229,9 +1073,8 @@ TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp)
tif->tif_dataoff += (cc + 1) & ~1;
return (1);
}
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing data for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing data for field \"%s\"",
+ _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
return (0);
}
@@ -1267,8 +1110,7 @@ TIFFRewriteDirectory( TIFF *tif )
if (!WriteOK(tif, &(tif->tif_header.tiff_diroff),
sizeof (tif->tif_diroff)))
{
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error updating TIFF header");
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error updating TIFF header");
return (0);
}
}
@@ -1282,8 +1124,7 @@ TIFFRewriteDirectory( TIFF *tif )
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error fetching directory count");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
@@ -1291,8 +1132,7 @@ TIFFRewriteDirectory( TIFF *tif )
(void) TIFFSeekFile(tif,
dircount * sizeof (TIFFDirEntry), SEEK_CUR);
if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error fetching directory link");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory link");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
@@ -1302,8 +1142,7 @@ TIFFRewriteDirectory( TIFF *tif )
(void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
tif->tif_diroff = 0;
if (!WriteOK(tif, &(tif->tif_diroff), sizeof (nextdir))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error writing directory link");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
return (0);
}
}
@@ -1317,7 +1156,8 @@ TIFFRewriteDirectory( TIFF *tif )
/*
- * Link the current directory into the directory chain for the file.
+ * Link the current directory into the
+ * directory chain for the file.
*/
static int
TIFFLinkDirectory(TIFF* tif)
@@ -1338,8 +1178,8 @@ TIFFLinkDirectory(TIFF* tif)
(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Error writing SubIFD directory link",
- tif->tif_name);
+ "%s: Error writing SubIFD directory link",
+ tif->tif_name);
return (0);
}
/*
@@ -1363,8 +1203,7 @@ TIFFLinkDirectory(TIFF* tif)
(toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE),
SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error writing TIFF header");
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing TIFF header");
return (0);
}
return (1);
@@ -1378,8 +1217,7 @@ TIFFLinkDirectory(TIFF* tif)
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error fetching directory count");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
@@ -1387,8 +1225,7 @@ TIFFLinkDirectory(TIFF* tif)
(void) TIFFSeekFile(tif,
dircount * sizeof (TIFFDirEntry), SEEK_CUR);
if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error fetching directory link");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory link");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
@@ -1397,8 +1234,7 @@ TIFFLinkDirectory(TIFF* tif)
off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
(void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Error writing directory link");
+ TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
return (0);
}
return (1);
diff --git a/src/libtiff/tif_dumpmode.c b/src/libtiff/tif_dumpmode.c
index c93763a..ade189d 100644
--- a/src/libtiff/tif_dumpmode.c
+++ b/src/libtiff/tif_dumpmode.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_dumpmode.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_dumpmode.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -45,7 +45,7 @@ DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
if (tif->tif_rawcc + n > tif->tif_rawdatasize)
n = tif->tif_rawdatasize - tif->tif_rawcc;
- assert( n > 0 );
+ assert( n > 0 );
/*
* Avoid copy if client has setup raw
@@ -71,8 +71,6 @@ static int
DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
{
(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",
diff --git a/src/libtiff/tif_error.c b/src/libtiff/tif_error.c
index f31c07e..ac6a6b5 100644
--- a/src/libtiff/tif_error.c
+++ b/src/libtiff/tif_error.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_error.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_error.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_extension.c b/src/libtiff/tif_extension.c
index 9fd1912..3d93d7f 100644
--- a/src/libtiff/tif_extension.c
+++ b/src/libtiff/tif_extension.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_extension.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_extension.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_fax3.c b/src/libtiff/tif_fax3.c
index 9c909c4..afca796 100644
--- a/src/libtiff/tif_fax3.c
+++ b/src/libtiff/tif_fax3.c
@@ -1,4 +1,4 @@
-/* $Id: tif_fax3.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_fax3.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
@@ -63,7 +63,6 @@ typedef struct {
char* faxdcs; /* Table 2/T.30 encoded session params */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
- TIFFPrintMethod printdir; /* super-class method */
} Fax3BaseState;
#define Fax3State(tif) ((Fax3BaseState*) (tif)->tif_data)
@@ -86,8 +85,6 @@ typedef struct {
unsigned char* refline; /* reference line for 2d decoding */
int k; /* #rows left that can be 2d encoded */
int maxk; /* max #rows that can be 2d encoded */
-
- int line;
} Fax3CodecState;
#define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif))
#define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif))
@@ -170,7 +167,6 @@ Fax3PreDecode(TIFF* tif, tsample_t s)
sp->refruns[0] = (uint32) sp->b.rowpixels;
sp->refruns[1] = 0;
}
- sp->line = 0;
return (1);
}
@@ -183,46 +179,46 @@ 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, "%s: Bad code word at line %lu of %s %lu (x %lu)",
+ tif->tif_name, (unsigned long) line, isTiled(tif) ? "tile" : "strip",
+ (unsigned long) (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
+ (unsigned long) a0);
}
-#define unexpected(table, a0) Fax3Unexpected(module, tif, sp->line, a0)
+#define unexpected(table, a0) Fax3Unexpected(module, tif, line, a0)
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);
+ "%s: Uncompressed data (not supported) at line %lu of %s %lu (x %lu)",
+ tif->tif_name, (unsigned long) line, isTiled(tif) ? "tile" : "strip",
+ (unsigned long) (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
+ (unsigned long) a0);
}
-#define extension(a0) Fax3Extension(module, tif, sp->line, a0)
+#define extension(a0) Fax3Extension(module, tif, 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: %s at line %lu of %s %lu (got %lu, expected %lu)",
+ tif->tif_name,
+ a0 < lastx ? "Premature EOL" : "Line length mismatch",
+ (unsigned long) line, isTiled(tif) ? "tile" : "strip",
+ (unsigned long) (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
+ (unsigned long) a0, lastx);
}
-#define badlength(a0,lastx) Fax3BadLength(module, tif, sp->line, a0, lastx)
+#define badlength(a0,lastx) Fax3BadLength(module, tif, 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)",
+ TIFFWarningExt(tif->tif_clientdata, module, "%s: Premature EOF at line %lu of %s %lu (x %lu)",
tif->tif_name,
- line, isTiled(tif) ? "tile" : "strip",
- (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
- a0);
+ (unsigned long) line, isTiled(tif) ? "tile" : "strip",
+ (unsigned long) (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
+ (unsigned long) a0);
}
-#define prematureEOF(a0) Fax3PrematureEOF(module, tif, sp->line, a0)
+#define prematureEOF(a0) Fax3PrematureEOF(module, tif, line, a0)
#define Nop
@@ -233,6 +229,7 @@ static int
Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
DECLARE_STATE(tif, sp, "Fax3Decode1D");
+ int line = 0;
(void) s;
CACHE_STATE(tif, sp);
@@ -251,7 +248,7 @@ Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
(*sp->fill)(buf, thisrun, pa, lastx);
buf += sp->b.rowbytes;
occ -= sp->b.rowbytes;
- sp->line++;
+ line++;
continue;
EOF1D: /* premature EOF */
CLEANUP_RUNS();
@@ -272,6 +269,7 @@ static int
Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
DECLARE_STATE_2D(tif, sp, "Fax3Decode2D");
+ int line = 0;
int is1D; /* current line is 1d/2d-encoded */
(void) s;
@@ -304,7 +302,7 @@ Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
SWAP(uint32*, sp->curruns, sp->refruns);
buf += sp->b.rowbytes;
occ -= sp->b.rowbytes;
- sp->line++;
+ line++;
continue;
EOF2D: /* premature EOF */
CLEANUP_RUNS();
@@ -494,14 +492,14 @@ Fax3SetupState(TIFF* tif)
);
nruns = needsRefLine ? 2*TIFFroundup(rowpixels,32) : rowpixels;
- nruns += 3;
- dsp->runs = (uint32*) _TIFFCheckMalloc(tif, 2*nruns, sizeof (uint32),
+
+ dsp->runs = (uint32*) _TIFFCheckMalloc(tif, 2*nruns+3, sizeof (uint32),
"for Group 3/4 run arrays");
if (dsp->runs == NULL)
return (0);
dsp->curruns = dsp->runs;
if (needsRefLine)
- dsp->refruns = dsp->runs + nruns;
+ dsp->refruns = dsp->runs + (nruns>>1);
else
dsp->refruns = NULL;
if (td->td_compression == COMPRESSION_CCITTFAX3
@@ -720,7 +718,6 @@ Fax3PreEncode(TIFF* tif, tsample_t s)
sp->k = sp->maxk-1;
} else
sp->k = sp->maxk = 0;
- sp->line = 0;
return (1);
}
@@ -776,7 +773,7 @@ static int32 find1span(unsigned char*, int32, int32);
* table. The ``base'' of the bit string is supplied
* along with the start+end bit indices.
*/
-static int32
+inline static int32
find0span(unsigned char* bp, int32 bs, int32 be)
{
int32 bits = be - bs;
@@ -835,7 +832,7 @@ find0span(unsigned char* bp, int32 bs, int32 be)
return (span);
}
-static int32
+inline static int32
find1span(unsigned char* bp, int32 bs, int32 be)
{
int32 bits = be - bs;
@@ -1077,7 +1074,6 @@ Fax3Cleanup(TIFF* tif)
tif->tif_tagmethods.vgetfield = sp->b.vgetparent;
tif->tif_tagmethods.vsetfield = sp->b.vsetparent;
- tif->tif_tagmethods.printdir = sp->b.printdir;
if (sp->runs)
_TIFFfree(sp->runs);
@@ -1086,9 +1082,6 @@ Fax3Cleanup(TIFF* tif)
if (Fax3State(tif)->subaddress)
_TIFFfree(Fax3State(tif)->subaddress);
- if (Fax3State(tif)->faxdcs)
- _TIFFfree(Fax3State(tif)->faxdcs);
-
_TIFFfree(tif->tif_data);
tif->tif_data = NULL;
@@ -1143,7 +1136,6 @@ static int
Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
{
Fax3BaseState* sp = Fax3State(tif);
- const TIFFFieldInfo* fip;
assert(sp != 0);
assert(sp->vsetparent != 0);
@@ -1151,10 +1143,10 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
switch (tag) {
case TIFFTAG_FAXMODE:
sp->mode = va_arg(ap, int);
- return 1; /* NB: pseudo tag */
+ return (1); /* NB: pseudo tag */
case TIFFTAG_FAXFILLFUNC:
DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
- return 1; /* NB: pseudo tag */
+ return (1); /* NB: pseudo tag */
case TIFFTAG_GROUP3OPTIONS:
/* XXX: avoid reading options if compression mismatches. */
if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
@@ -1189,14 +1181,9 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
default:
return (*sp->vsetparent)(tif, tag, ap);
}
-
- if ((fip = _TIFFFieldWithTag(tif, tag)))
- TIFFSetFieldBit(tif, fip->field_bit);
- else
- return 0;
-
+ TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
tif->tif_flags |= TIFF_DIRTYDIRECT;
- return 1;
+ return (1);
}
static int
@@ -1204,8 +1191,6 @@ Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap)
{
Fax3BaseState* sp = Fax3State(tif);
- assert(sp != 0);
-
switch (tag) {
case TIFFTAG_FAXMODE:
*va_arg(ap, int*) = sp->mode;
@@ -1249,8 +1234,6 @@ Fax3PrintDir(TIFF* tif, FILE* fd, long flags)
{
Fax3BaseState* sp = Fax3State(tif);
- assert(sp != 0);
-
(void) flags;
if (TIFFFieldSet(tif,FIELD_OPTIONS)) {
const char* sep = " ";
@@ -1311,15 +1294,6 @@ InitCCITTFax3(TIFF* tif)
{
Fax3BaseState* sp;
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, "InitCCITTFax3",
- "Merging common CCITT Fax codec-specific tags failed");
- return 0;
- }
-
/*
* Allocate state block so tag methods have storage to record values.
*/
@@ -1336,13 +1310,14 @@ InitCCITTFax3(TIFF* tif)
sp->rw_mode = tif->tif_mode;
/*
- * Override parent get/set field methods.
+ * Merge codec-specific tag information and
+ * override parent get/set field methods.
*/
+ _TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = Fax3VGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = Fax3VSetField; /* hook for codec tags */
- sp->printdir = tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */
sp->groupoptions = 0;
sp->recvparams = 0;
@@ -1380,21 +1355,14 @@ TIFFInitCCITTFax3(TIFF* tif, int scheme)
{
(void) scheme;
if (InitCCITTFax3(tif)) {
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3",
- "Merging CCITT Fax 3 codec-specific tags failed");
- return 0;
- }
+ _TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo));
/*
* The default format is Class/F-style w/o RTC.
*/
return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_CLASSF);
} else
- return 01;
+ return (0);
}
/*
@@ -1410,6 +1378,7 @@ static int
Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
DECLARE_STATE_2D(tif, sp, "Fax4Decode");
+ int line = 0;
(void) s;
CACHE_STATE(tif, sp);
@@ -1432,7 +1401,7 @@ Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
SWAP(uint32*, sp->curruns, sp->refruns);
buf += sp->b.rowbytes;
occ -= sp->b.rowbytes;
- sp->line++;
+ line++;
continue;
EOFG4:
NeedBits16( 13, BADG4 );
@@ -1488,14 +1457,7 @@ TIFFInitCCITTFax4(TIFF* tif, int scheme)
{
(void) scheme;
if (InitCCITTFax3(tif)) { /* reuse G3 support */
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax4",
- "Merging CCITT Fax 4 codec-specific tags failed");
- return 0;
- }
+ _TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo));
tif->tif_decoderow = Fax4Decode;
tif->tif_decodestrip = Fax4Decode;
@@ -1525,6 +1487,7 @@ Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
DECLARE_STATE(tif, sp, "Fax3DecodeRLE");
int mode = sp->b.mode;
+ int line = 0;
(void) s;
CACHE_STATE(tif, sp);
@@ -1554,7 +1517,7 @@ Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
}
buf += sp->b.rowbytes;
occ -= sp->b.rowbytes;
- sp->line++;
+ line++;
continue;
EOFRLE: /* premature EOF */
(*sp->fill)(buf, thisrun, pa, lastx);
diff --git a/src/libtiff/tif_fax3.h b/src/libtiff/tif_fax3.h
index 51c7bfa..bf4d4f1 100644
--- a/src/libtiff/tif_fax3.h
+++ b/src/libtiff/tif_fax3.h
@@ -1,4 +1,4 @@
-/* $Id: tif_fax3.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_fax3.h,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
diff --git a/src/libtiff/tif_flush.c b/src/libtiff/tif_flush.c
index 5eab382..4bce063 100644
--- a/src/libtiff/tif_flush.c
+++ b/src/libtiff/tif_flush.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_flush.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_flush.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_getimage.c b/src/libtiff/tif_getimage.c
index f9d85e0..b3263b8 100644
--- a/src/libtiff/tif_getimage.c
+++ b/src/libtiff/tif_getimage.c
@@ -1,4 +1,4 @@
-/* $Id: tif_getimage.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_getimage.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@@ -32,13 +32,14 @@
#include "tiffiop.h"
#include <stdio.h>
-static int gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32);
-static int gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
-static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32);
-static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
-static int PickContigCase(TIFFRGBAImage*);
-static int PickSeparateCase(TIFFRGBAImage*);
-static const char photoTag[] = "PhotometricInterpretation";
+static int gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32);
+static int gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
+static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32);
+static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
+static int pickTileContigCase(TIFFRGBAImage*);
+static int pickTileSeparateCase(TIFFRGBAImage*);
+
+static const char photoTag[] = "PhotometricInterpretation";
/*
* Helper constants used in Orientation tag handling
@@ -71,122 +72,118 @@ TIFFDisplay display_sRGB = {
int
TIFFRGBAImageOK(TIFF* tif, char emsg[1024])
{
- TIFFDirectory* td = &tif->tif_dir;
- uint16 photometric;
- int colorchannels;
+ TIFFDirectory* td = &tif->tif_dir;
+ uint16 photometric;
+ int colorchannels;
- if (!tif->tif_decodestatus) {
- sprintf(emsg, "Sorry, requested compression method is not configured");
- return (0);
+ if (!tif->tif_decodestatus) {
+ sprintf(emsg, "Sorry, requested compression method is not configured");
+ return (0);
+ }
+ switch (td->td_bitspersample) {
+ case 1: case 2: case 4:
+ case 8: case 16:
+ break;
+ default:
+ sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
+ td->td_bitspersample);
+ return (0);
+ }
+ colorchannels = td->td_samplesperpixel - td->td_extrasamples;
+ if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) {
+ switch (colorchannels) {
+ case 1:
+ photometric = PHOTOMETRIC_MINISBLACK;
+ break;
+ case 3:
+ photometric = PHOTOMETRIC_RGB;
+ break;
+ default:
+ sprintf(emsg, "Missing needed %s tag", photoTag);
+ return (0);
}
- switch (td->td_bitspersample) {
- case 1:
- case 2:
- case 4:
- case 8:
- case 16:
- break;
- default:
- sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
- td->td_bitspersample);
- return (0);
+ }
+ switch (photometric) {
+ case PHOTOMETRIC_MINISWHITE:
+ case PHOTOMETRIC_MINISBLACK:
+ case PHOTOMETRIC_PALETTE:
+ if (td->td_planarconfig == PLANARCONFIG_CONTIG
+ && td->td_samplesperpixel != 1
+ && td->td_bitspersample < 8 ) {
+ sprintf(emsg,
+ "Sorry, can not handle contiguous data with %s=%d, "
+ "and %s=%d and Bits/Sample=%d",
+ photoTag, photometric,
+ "Samples/pixel", td->td_samplesperpixel,
+ td->td_bitspersample);
+ return (0);
}
- colorchannels = td->td_samplesperpixel - td->td_extrasamples;
- if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) {
- switch (colorchannels) {
- case 1:
- photometric = PHOTOMETRIC_MINISBLACK;
- break;
- case 3:
- photometric = PHOTOMETRIC_RGB;
- break;
- default:
- sprintf(emsg, "Missing needed %s tag", photoTag);
- return (0);
+ /*
+ ** We should likely validate that any extra samples are either
+ ** to be ignored, or are alpha, and if alpha we should try to use
+ ** them. But for now we won't bother with this.
+ */
+ break;
+ case PHOTOMETRIC_YCBCR:
+ if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
+ sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d",
+ "Planarconfiguration", td->td_planarconfig);
+ return (0);
+ }
+ break;
+ case PHOTOMETRIC_RGB:
+ if (colorchannels < 3) {
+ sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
+ "Color channels", colorchannels);
+ return (0);
+ }
+ break;
+ case PHOTOMETRIC_SEPARATED:
+ {
+ uint16 inkset;
+ TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
+ if (inkset != INKSET_CMYK) {
+ sprintf(emsg,
+ "Sorry, can not handle separated image with %s=%d",
+ "InkSet", inkset);
+ return 0;
+ }
+ if (td->td_samplesperpixel < 4) {
+ sprintf(emsg,
+ "Sorry, can not handle separated image with %s=%d",
+ "Samples/pixel", td->td_samplesperpixel);
+ return 0;
}
+ break;
}
- switch (photometric) {
- case PHOTOMETRIC_MINISWHITE:
- case PHOTOMETRIC_MINISBLACK:
- case PHOTOMETRIC_PALETTE:
- if (td->td_planarconfig == PLANARCONFIG_CONTIG
- && td->td_samplesperpixel != 1
- && td->td_bitspersample < 8 ) {
- sprintf(emsg,
- "Sorry, can not handle contiguous data with %s=%d, "
- "and %s=%d and Bits/Sample=%d",
- photoTag, photometric,
- "Samples/pixel", td->td_samplesperpixel,
- td->td_bitspersample);
- return (0);
- }
- /*
- * We should likely validate that any extra samples are either
- * to be ignored, or are alpha, and if alpha we should try to use
- * them. But for now we won't bother with this.
- */
- break;
- case PHOTOMETRIC_YCBCR:
- /*
- * TODO: if at all meaningful and useful, make more complete
- * support check here, or better still, refactor to let supporting
- * code decide whether there is support and what meaningfull
- * error to return
- */
- break;
- case PHOTOMETRIC_RGB:
- if (colorchannels < 3) {
- sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
- "Color channels", colorchannels);
- return (0);
- }
- break;
- case PHOTOMETRIC_SEPARATED:
- {
- uint16 inkset;
- TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
- if (inkset != INKSET_CMYK) {
- sprintf(emsg,
- "Sorry, can not handle separated image with %s=%d",
- "InkSet", inkset);
- return 0;
- }
- if (td->td_samplesperpixel < 4) {
- sprintf(emsg,
- "Sorry, can not handle separated image with %s=%d",
- "Samples/pixel", td->td_samplesperpixel);
- return 0;
- }
- break;
- }
- case PHOTOMETRIC_LOGL:
- if (td->td_compression != COMPRESSION_SGILOG) {
- sprintf(emsg, "Sorry, LogL data must have %s=%d",
- "Compression", COMPRESSION_SGILOG);
- return (0);
- }
- break;
- case PHOTOMETRIC_LOGLUV:
- if (td->td_compression != COMPRESSION_SGILOG &&
- td->td_compression != COMPRESSION_SGILOG24) {
- sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
- "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
- return (0);
- }
- if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
- sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
- "Planarconfiguration", td->td_planarconfig);
- return (0);
- }
- break;
- case PHOTOMETRIC_CIELAB:
- break;
- default:
- sprintf(emsg, "Sorry, can not handle image with %s=%d",
- photoTag, photometric);
- return (0);
+ case PHOTOMETRIC_LOGL:
+ if (td->td_compression != COMPRESSION_SGILOG) {
+ sprintf(emsg, "Sorry, LogL data must have %s=%d",
+ "Compression", COMPRESSION_SGILOG);
+ return (0);
+ }
+ break;
+ case PHOTOMETRIC_LOGLUV:
+ if (td->td_compression != COMPRESSION_SGILOG &&
+ td->td_compression != COMPRESSION_SGILOG24) {
+ sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
+ "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
+ return (0);
}
- return (1);
+ if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
+ sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
+ "Planarconfiguration", td->td_planarconfig);
+ return (0);
+ }
+ break;
+ case PHOTOMETRIC_CIELAB:
+ break;
+ default:
+ sprintf(emsg, "Sorry, can not handle image with %s=%d",
+ photoTag, photometric);
+ return (0);
+ }
+ return (1);
}
void
@@ -202,6 +199,7 @@ TIFFRGBAImageEnd(TIFFRGBAImage* img)
_TIFFfree(img->ycbcr), img->ycbcr = NULL;
if (img->cielab)
_TIFFfree(img->cielab), img->cielab = NULL;
+
if( img->redcmap ) {
_TIFFfree( img->redcmap );
_TIFFfree( img->greencmap );
@@ -223,227 +221,221 @@ isCCITTCompression(TIFF* tif)
int
TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
{
- uint16* sampleinfo;
- uint16 extrasamples;
- uint16 planarconfig;
- uint16 compress;
- int colorchannels;
- uint16 *red_orig, *green_orig, *blue_orig;
- int n_color;
-
- /* Initialize to normal values */
- img->row_offset = 0;
- img->col_offset = 0;
- img->redcmap = NULL;
- img->greencmap = NULL;
- img->bluecmap = NULL;
- img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */
-
- img->tif = tif;
- img->stoponerr = stop;
- TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
- switch (img->bitspersample) {
- case 1:
- case 2:
- case 4:
- case 8:
- case 16:
- break;
- default:
- sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
- img->bitspersample);
- return (0);
- }
- img->alpha = 0;
- TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
- TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
- &extrasamples, &sampleinfo);
- if (extrasamples >= 1)
- {
- switch (sampleinfo[0]) {
- case EXTRASAMPLE_UNSPECIFIED: /* Workaround for some images without */
- if (img->samplesperpixel > 3) /* correct info about alpha channel */
- img->alpha = EXTRASAMPLE_ASSOCALPHA;
- break;
- case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */
- case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */
- img->alpha = sampleinfo[0];
- break;
- }
+ uint16* sampleinfo;
+ uint16 extrasamples;
+ uint16 planarconfig;
+ uint16 compress;
+ int colorchannels;
+ uint16 *red_orig, *green_orig, *blue_orig;
+ int n_color;
+
+ /* Initialize to normal values */
+ img->row_offset = 0;
+ img->col_offset = 0;
+ img->redcmap = NULL;
+ img->greencmap = NULL;
+ img->bluecmap = NULL;
+ img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */
+
+ img->tif = tif;
+ img->stoponerr = stop;
+ TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
+ switch (img->bitspersample) {
+ case 1: case 2: case 4:
+ case 8: case 16:
+ break;
+ default:
+ sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
+ img->bitspersample);
+ return (0);
+ }
+ img->alpha = 0;
+ TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
+ TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
+ &extrasamples, &sampleinfo);
+ if (extrasamples >= 1)
+ {
+ switch (sampleinfo[0]) {
+ case EXTRASAMPLE_UNSPECIFIED: /* Workaround for some images without */
+ if (img->samplesperpixel > 3) /* correct info about alpha channel */
+ img->alpha = EXTRASAMPLE_ASSOCALPHA;
+ break;
+ case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */
+ case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */
+ img->alpha = sampleinfo[0];
+ break;
}
+ }
#ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA
- if( !TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
+ if( !TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
+ img->photometric = PHOTOMETRIC_MINISWHITE;
+
+ if( extrasamples == 0
+ && img->samplesperpixel == 4
+ && img->photometric == PHOTOMETRIC_RGB )
+ {
+ img->alpha = EXTRASAMPLE_ASSOCALPHA;
+ extrasamples = 1;
+ }
+#endif
+
+ colorchannels = img->samplesperpixel - extrasamples;
+ TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
+ TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
+ if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
+ switch (colorchannels) {
+ case 1:
+ if (isCCITTCompression(tif))
img->photometric = PHOTOMETRIC_MINISWHITE;
+ else
+ img->photometric = PHOTOMETRIC_MINISBLACK;
+ break;
+ case 3:
+ img->photometric = PHOTOMETRIC_RGB;
+ break;
+ default:
+ sprintf(emsg, "Missing needed %s tag", photoTag);
+ return (0);
+ }
+ }
+ switch (img->photometric) {
+ case PHOTOMETRIC_PALETTE:
+ if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
+ &red_orig, &green_orig, &blue_orig)) {
+ sprintf(emsg, "Missing required \"Colormap\" tag");
+ return (0);
+ }
- if( extrasamples == 0
- && img->samplesperpixel == 4
- && img->photometric == PHOTOMETRIC_RGB )
- {
- img->alpha = EXTRASAMPLE_ASSOCALPHA;
- extrasamples = 1;
+ /* copy the colormaps so we can modify them */
+ n_color = (1L << img->bitspersample);
+ img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
+ img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
+ 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);
+ }
+
+ _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 );
+ _TIFFmemcpy( img->greencmap, green_orig, n_color * 2 );
+ _TIFFmemcpy( img->bluecmap, blue_orig, n_color * 2 );
+
+ /* fall thru... */
+ case PHOTOMETRIC_MINISWHITE:
+ case PHOTOMETRIC_MINISBLACK:
+ if (planarconfig == PLANARCONFIG_CONTIG
+ && img->samplesperpixel != 1
+ && img->bitspersample < 8 ) {
+ sprintf(emsg,
+ "Sorry, can not handle contiguous data with %s=%d, "
+ "and %s=%d and Bits/Sample=%d",
+ photoTag, img->photometric,
+ "Samples/pixel", img->samplesperpixel,
+ img->bitspersample);
+ return (0);
}
-#endif
+ break;
+ case PHOTOMETRIC_YCBCR:
+ if (planarconfig != PLANARCONFIG_CONTIG) {
+ sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d",
+ "Planarconfiguration", planarconfig);
+ return (0);
+ }
+ /* It would probably be nice to have a reality check here. */
+ if (planarconfig == PLANARCONFIG_CONTIG)
+ /* can rely on libjpeg to convert to RGB */
+ /* XXX should restore current state on exit */
+ switch (compress) {
+ case COMPRESSION_OJPEG:
+ case COMPRESSION_JPEG:
+ TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
+ img->photometric = PHOTOMETRIC_RGB;
+ break;
- colorchannels = img->samplesperpixel - extrasamples;
- TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
- TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
- if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
- switch (colorchannels) {
- case 1:
- if (isCCITTCompression(tif))
- img->photometric = PHOTOMETRIC_MINISWHITE;
- else
- img->photometric = PHOTOMETRIC_MINISBLACK;
- break;
- case 3:
- img->photometric = PHOTOMETRIC_RGB;
- break;
- default:
- sprintf(emsg, "Missing needed %s tag", photoTag);
- return (0);
- }
+ default:
+ /* do nothing */;
+ break;
+ }
+ break;
+ case PHOTOMETRIC_RGB:
+ if (colorchannels < 3) {
+ sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
+ "Color channels", colorchannels);
+ return (0);
}
- switch (img->photometric) {
- case PHOTOMETRIC_PALETTE:
- if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
- &red_orig, &green_orig, &blue_orig)) {
- sprintf(emsg, "Missing required \"Colormap\" tag");
- return (0);
- }
-
- /* copy the colormaps so we can modify them */
- n_color = (1L << img->bitspersample);
- img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
- img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
- 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);
- }
-
- _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 );
- _TIFFmemcpy( img->greencmap, green_orig, n_color * 2 );
- _TIFFmemcpy( img->bluecmap, blue_orig, n_color * 2 );
-
- /* fall thru... */
- case PHOTOMETRIC_MINISWHITE:
- case PHOTOMETRIC_MINISBLACK:
- if (planarconfig == PLANARCONFIG_CONTIG
- && img->samplesperpixel != 1
- && img->bitspersample < 8 ) {
- sprintf(emsg,
- "Sorry, can not handle contiguous data with %s=%d, "
- "and %s=%d and Bits/Sample=%d",
- photoTag, img->photometric,
- "Samples/pixel", img->samplesperpixel,
- img->bitspersample);
- return (0);
- }
- break;
- case PHOTOMETRIC_YCBCR:
- /* It would probably be nice to have a reality check here. */
- if (planarconfig == PLANARCONFIG_CONTIG)
- /* can rely on libjpeg to convert to RGB */
- /* XXX should restore current state on exit */
- switch (compress) {
- case COMPRESSION_JPEG:
- /*
- * TODO: when complete tests verify complete desubsampling
- * and YCbCr handling, remove use of TIFFTAG_JPEGCOLORMODE in
- * favor of tif_getimage.c native handling
- */
- TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
- img->photometric = PHOTOMETRIC_RGB;
- break;
- default:
- /* do nothing */;
- break;
- }
- /*
- * TODO: if at all meaningful and useful, make more complete
- * support check here, or better still, refactor to let supporting
- * code decide whether there is support and what meaningfull
- * error to return
- */
- break;
- case PHOTOMETRIC_RGB:
- if (colorchannels < 3) {
- sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
- "Color channels", colorchannels);
- return (0);
- }
- break;
- case PHOTOMETRIC_SEPARATED:
- {
- uint16 inkset;
- TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
- if (inkset != INKSET_CMYK) {
- sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
- "InkSet", inkset);
- return (0);
- }
- if (img->samplesperpixel < 4) {
- sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
- "Samples/pixel", img->samplesperpixel);
- return (0);
- }
- }
- break;
- case PHOTOMETRIC_LOGL:
- if (compress != COMPRESSION_SGILOG) {
- sprintf(emsg, "Sorry, LogL data must have %s=%d",
- "Compression", COMPRESSION_SGILOG);
- return (0);
- }
- TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
- img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
- img->bitspersample = 8;
- break;
- case PHOTOMETRIC_LOGLUV:
- 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);
- }
- if (planarconfig != PLANARCONFIG_CONTIG) {
- sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
- "Planarconfiguration", planarconfig);
- return (0);
- }
- TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
- img->photometric = PHOTOMETRIC_RGB; /* little white lie */
- img->bitspersample = 8;
- break;
- case PHOTOMETRIC_CIELAB:
- break;
- default:
- sprintf(emsg, "Sorry, can not handle image with %s=%d",
- photoTag, img->photometric);
- return (0);
+ break;
+ case PHOTOMETRIC_SEPARATED: {
+ uint16 inkset;
+ TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
+ if (inkset != INKSET_CMYK) {
+ sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
+ "InkSet", inkset);
+ return (0);
}
- img->Map = NULL;
- img->BWmap = NULL;
- img->PALmap = NULL;
- img->ycbcr = NULL;
- img->cielab = 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);
- if (img->isContig) {
- if (!PickContigCase(img)) {
- sprintf(emsg, "Sorry, can not handle image");
- return 0;
- }
- } else {
- if (!PickSeparateCase(img)) {
- sprintf(emsg, "Sorry, can not handle image");
- return 0;
- }
+ if (img->samplesperpixel < 4) {
+ sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
+ "Samples/pixel", img->samplesperpixel);
+ return (0);
}
- return 1;
+ break;
+ }
+ case PHOTOMETRIC_LOGL:
+ if (compress != COMPRESSION_SGILOG) {
+ sprintf(emsg, "Sorry, LogL data must have %s=%d",
+ "Compression", COMPRESSION_SGILOG);
+ return (0);
+ }
+ TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
+ img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
+ img->bitspersample = 8;
+ break;
+ case PHOTOMETRIC_LOGLUV:
+ 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);
+ }
+ if (planarconfig != PLANARCONFIG_CONTIG) {
+ sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
+ "Planarconfiguration", planarconfig);
+ return (0);
+ }
+ TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
+ img->photometric = PHOTOMETRIC_RGB; /* little white lie */
+ img->bitspersample = 8;
+ break;
+ case PHOTOMETRIC_CIELAB:
+ break;
+ default:
+ sprintf(emsg, "Sorry, can not handle image with %s=%d",
+ photoTag, img->photometric);
+ return (0);
+ }
+ img->Map = NULL;
+ img->BWmap = NULL;
+ img->PALmap = NULL;
+ img->ycbcr = NULL;
+ img->cielab = 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);
+ if (img->isContig) {
+ img->get = TIFFIsTiled(tif) ? gtTileContig : gtStripContig;
+ if (!pickTileContigCase(img)) {
+ sprintf(emsg, "Sorry, can not handle image");
+ return 0;
+ }
+ } else {
+ img->get = TIFFIsTiled(tif) ? gtTileSeparate : gtStripSeparate;
+ if (!pickTileSeparateCase(img)) {
+ sprintf(emsg, "Sorry, can not handle image");
+ return 0;
+ }
+ }
+ return 1;
}
int
@@ -481,7 +473,7 @@ TIFFReadRGBAImageOriented(TIFF* tif,
rwidth, img.height);
TIFFRGBAImageEnd(&img);
} else {
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
+ TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), emsg);
ok = 0;
}
return (ok);
@@ -662,120 +654,119 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
static int
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;
- uint32 tw, th;
- unsigned char* buf;
- unsigned char* p0;
- unsigned char* p1;
- unsigned char* p2;
- unsigned char* pa;
- tsize_t tilesize;
- int32 fromskew, toskew;
- int alpha = img->alpha;
- uint32 nrow;
- int ret = 1, flip;
-
- tilesize = TIFFTileSize(tif);
- buf = (unsigned char*) _TIFFmalloc((alpha?4:3)*tilesize);
- if (buf == 0) {
+ TIFF* tif = img->tif;
+ tileSeparateRoutine put = img->put.separate;
+ uint32 col, row, y, rowstoread;
+ uint32 pos;
+ uint32 tw, th;
+ unsigned char* buf;
+ unsigned char* r;
+ unsigned char* g;
+ unsigned char* b;
+ unsigned char* a;
+ tsize_t tilesize;
+ int32 fromskew, toskew;
+ int alpha = img->alpha;
+ uint32 nrow;
+ int ret = 1, flip;
+
+ tilesize = TIFFTileSize(tif);
+ buf = (unsigned char*) _TIFFmalloc(4*tilesize);
+ if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
return (0);
- }
- _TIFFmemset(buf, 0, (alpha?4:3)*tilesize);
- p0 = buf;
- p1 = p0 + tilesize;
- p2 = p1 + tilesize;
- pa = (alpha?(p2+tilesize):NULL);
- TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
- TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
-
- flip = setorientation(img);
- if (flip & FLIP_VERTICALLY) {
- y = h - 1;
- toskew = -(int32)(tw + w);
- }
- else {
- y = 0;
- toskew = -(int32)(tw - w);
- }
+ }
+ _TIFFmemset(buf, 0, 4*tilesize);
+ r = buf;
+ g = r + tilesize;
+ b = g + tilesize;
+ a = b + tilesize;
+ if (!alpha)
+ _TIFFmemset(a, 0xff, tilesize);
+ TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
+ TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
- 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 (TIFFReadTile(tif, p0, col+img->col_offset,
- row+img->row_offset,0,0) < 0 && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (TIFFReadTile(tif, p1, col+img->col_offset,
- row+img->row_offset,0,1) < 0 && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (TIFFReadTile(tif, p2, col+img->col_offset,
- row+img->row_offset,0,2) < 0 && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (alpha)
- {
- if (TIFFReadTile(tif,pa,col+img->col_offset,
- row+img->row_offset,0,3) < 0 && img->stoponerr)
- {
- ret = 0;
- break;
- }
- }
-
- pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
-
- if (col + tw > w)
- {
- /*
- * Tile is clipped horizontally. Calculate
- * visible portion and skewing factors.
- */
- uint32 npix = w - col;
- fromskew = tw - npix;
- (*put)(img, raster+y*w+col, col, y,
- npix, nrow, fromskew, toskew + fromskew,
- p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
- } else {
- (*put)(img, raster+y*w+col, col, y,
- tw, nrow, 0, toskew, p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
- }
- }
+ flip = setorientation(img);
+ if (flip & FLIP_VERTICALLY) {
+ y = h - 1;
+ toskew = -(int32)(tw + w);
+ }
+ else {
+ y = 0;
+ toskew = -(int32)(tw - w);
+ }
- y += (flip & FLIP_VERTICALLY ?-(int32) nrow : (int32) nrow);
- }
+ 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 (TIFFReadTile(tif, r, col+img->col_offset,
+ row+img->row_offset,0,0) < 0 && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (TIFFReadTile(tif, g, col+img->col_offset,
+ row+img->row_offset,0,1) < 0 && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (TIFFReadTile(tif, b, col+img->col_offset,
+ row+img->row_offset,0,2) < 0 && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (alpha && TIFFReadTile(tif,a,col+img->col_offset,
+ row+img->row_offset,0,3) < 0 && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
- if (flip & FLIP_HORIZONTALLY) {
- uint32 line;
+ pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
- for (line = 0; line < h; line++) {
- uint32 *left = raster + (line * w);
- uint32 *right = left + w - 1;
+ if (col + tw > w)
+ {
+ /*
+ * Tile is clipped horizontally. Calculate
+ * visible portion and skewing factors.
+ */
+ uint32 npix = w - col;
+ fromskew = tw - npix;
+ (*put)(img, raster+y*w+col, col, y,
+ npix, nrow, fromskew, toskew + fromskew,
+ r + pos, g + pos, b + pos, a + pos);
+ } else {
+ (*put)(img, raster+y*w+col, col, y,
+ tw, nrow, 0, toskew, r + pos, g + pos, b + pos, a + pos);
+ }
+ }
- while ( left < right ) {
- uint32 temp = *left;
- *left = *right;
- *right = temp;
- left++, right--;
- }
- }
- }
+ y += (flip & FLIP_VERTICALLY ?-(int32) nrow : (int32) nrow);
+ }
- _TIFFfree(buf);
- return (ret);
+ if (flip & FLIP_HORIZONTALLY) {
+ uint32 line;
+
+ for (line = 0; line < h; line++) {
+ uint32 *left = raster + (line * w);
+ uint32 *right = left + w - 1;
+
+ while ( left < right ) {
+ uint32 temp = *left;
+ *left = *right;
+ *right = temp;
+ left++, right--;
+ }
+ }
+ }
+
+ _TIFFfree(buf);
+ return (ret);
}
/*
@@ -787,78 +778,73 @@ gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
static int
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;
- unsigned char* buf;
- uint32 rowsperstrip;
- uint16 subsamplinghor,subsamplingver;
- uint32 imagewidth = img->width;
- tsize_t scanline;
- int32 fromskew, toskew;
- int ret = 1, flip;
-
- buf = (unsigned char*) _TIFFmalloc(TIFFStripSize(tif));
- if (buf == 0) {
+ TIFF* tif = img->tif;
+ tileContigRoutine put = img->put.contig;
+ uint32 row, y, nrow, rowstoread;
+ uint32 pos;
+ unsigned char* buf;
+ uint32 rowsperstrip;
+ uint32 imagewidth = img->width;
+ tsize_t scanline;
+ int32 fromskew, toskew;
+ int ret = 1, flip;
+
+ buf = (unsigned char*) _TIFFmalloc(TIFFStripSize(tif));
+ if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
return (0);
- }
- _TIFFmemset(buf, 0, TIFFStripSize(tif));
-
- flip = setorientation(img);
- if (flip & FLIP_VERTICALLY) {
- y = h - 1;
- toskew = -(int32)(w + w);
- } else {
- y = 0;
- toskew = -(int32)(w - w);
- }
+ }
+ _TIFFmemset(buf, 0, TIFFStripSize(tif));
- TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
- TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);
- scanline = TIFFNewScanlineSize(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);
- nrowsub = nrow;
- if ((nrowsub%subsamplingver)!=0)
- nrowsub+=subsamplingver-nrowsub%subsamplingver;
- if (TIFFReadEncodedStrip(tif,
- TIFFComputeStrip(tif,row+img->row_offset, 0),
- buf,
- ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0
- && img->stoponerr)
- {
- ret = 0;
- break;
- }
+ flip = setorientation(img);
+ if (flip & FLIP_VERTICALLY) {
+ y = h - 1;
+ toskew = -(int32)(w + w);
+ } else {
+ y = 0;
+ toskew = -(int32)(w - w);
+ }
- pos = ((row + img->row_offset) % rowsperstrip) * scanline;
- (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf + pos);
- y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
- }
+ TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
+ 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);
+ if (TIFFReadEncodedStrip(tif,
+ TIFFComputeStrip(tif,row+img->row_offset, 0),
+ buf,
+ ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
+ && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
- if (flip & FLIP_HORIZONTALLY) {
- uint32 line;
+ pos = ((row + img->row_offset) % rowsperstrip) * scanline;
+ (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf + pos);
+ y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
+ }
- for (line = 0; line < h; line++) {
- uint32 *left = raster + (line * w);
- uint32 *right = left + w - 1;
+ if (flip & FLIP_HORIZONTALLY) {
+ uint32 line;
- while ( left < right ) {
- uint32 temp = *left;
- *left = *right;
- *right = temp;
- left++, right--;
- }
- }
- }
+ for (line = 0; line < h; line++) {
+ uint32 *left = raster + (line * w);
+ uint32 *right = left + w - 1;
+
+ while ( left < right ) {
+ uint32 temp = *left;
+ *left = *right;
+ *right = temp;
+ left++, right--;
+ }
+ }
+ }
- _TIFFfree(buf);
- return (ret);
+ _TIFFfree(buf);
+ return (ret);
}
/*
@@ -870,105 +856,105 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
static int
gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
- TIFF* tif = img->tif;
- tileSeparateRoutine put = img->put.separate;
- unsigned char *buf;
- unsigned char *p0, *p1, *p2, *pa;
- uint32 row, y, nrow, rowstoread;
- uint32 pos;
- tsize_t scanline;
- uint32 rowsperstrip, offset_row;
- uint32 imagewidth = img->width;
- tsize_t stripsize;
- int32 fromskew, toskew;
- int alpha = img->alpha;
- int ret = 1, flip;
-
- stripsize = TIFFStripSize(tif);
- p0 = buf = (unsigned char *)_TIFFmalloc((alpha?4:3)*stripsize);
- if (buf == 0) {
+ TIFF* tif = img->tif;
+ tileSeparateRoutine put = img->put.separate;
+ unsigned char *buf;
+ unsigned char *r, *g, *b, *a;
+ uint32 row, y, nrow, rowstoread;
+ uint32 pos;
+ tsize_t scanline;
+ uint32 rowsperstrip, offset_row;
+ uint32 imagewidth = img->width;
+ tsize_t stripsize;
+ int32 fromskew, toskew;
+ int alpha = img->alpha;
+ int ret = 1, flip;
+
+ stripsize = TIFFStripSize(tif);
+ r = buf = (unsigned char *)_TIFFmalloc(4*stripsize);
+ if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
return (0);
- }
- _TIFFmemset(buf, 0, (alpha?4:3)*stripsize);
- p1 = p0 + stripsize;
- p2 = p1 + stripsize;
- pa = (alpha?(p2+stripsize):NULL);
-
- flip = setorientation(img);
- if (flip & FLIP_VERTICALLY) {
- y = h - 1;
- toskew = -(int32)(w + w);
- }
- else {
- y = 0;
- toskew = -(int32)(w - w);
- }
+ }
+ _TIFFmemset(buf, 0, 4*stripsize);
+ g = r + stripsize;
+ b = g + stripsize;
+ a = b + stripsize;
+ if (!alpha)
+ _TIFFmemset(a, 0xff, stripsize);
- TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
- 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 (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
- p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
- && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
- p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
- && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
- p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
- && img->stoponerr)
- {
- ret = 0;
- break;
- }
- if (alpha)
- {
- if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3),
- pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
- && img->stoponerr)
- {
- ret = 0;
- break;
- }
- }
+ flip = setorientation(img);
+ if (flip & FLIP_VERTICALLY) {
+ y = h - 1;
+ toskew = -(int32)(w + w);
+ }
+ else {
+ y = 0;
+ toskew = -(int32)(w - w);
+ }
- pos = ((row + img->row_offset) % rowsperstrip) * scanline;
- (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, p0 + pos, p1 + pos,
- p2 + pos, (alpha?(pa+pos):NULL));
- y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
- }
+ TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
+ 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 (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
+ r, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
+ && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
+ g, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
+ && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
+ b, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
+ && img->stoponerr)
+ {
+ ret = 0;
+ break;
+ }
+ if (alpha &&
+ (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3),
+ a, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
+ && img->stoponerr))
+ {
+ ret = 0;
+ break;
+ }
- if (flip & FLIP_HORIZONTALLY) {
- uint32 line;
+ pos = ((row + img->row_offset) % rowsperstrip) * scanline;
+ (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, r + pos, g + pos,
+ b + pos, a + pos);
+ y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
+ }
- for (line = 0; line < h; line++) {
- uint32 *left = raster + (line * w);
- uint32 *right = left + w - 1;
+ if (flip & FLIP_HORIZONTALLY) {
+ uint32 line;
- while ( left < right ) {
- uint32 temp = *left;
- *left = *right;
- *right = temp;
- left++, right--;
- }
- }
- }
+ for (line = 0; line < h; line++) {
+ uint32 *left = raster + (line * w);
+ uint32 *right = left + w - 1;
+
+ while ( left < right ) {
+ uint32 temp = *left;
+ *left = *right;
+ *right = temp;
+ left++, right--;
+ }
+ }
+ }
- _TIFFfree(buf);
- return (ret);
+ _TIFFfree(buf);
+ return (ret);
}
/*
@@ -977,9 +963,9 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
* ABGR pixels (i.e. suitable for passing to lrecwrite.)
*
* The routines have been created according to the most
- * important cases and optimized. PickContigCase and
- * PickSeparateCase analyze the parameters and select
- * the appropriate "get" and "put" routine to use.
+ * important cases and optimized. pickTileContigCase and
+ * pickTileSeparateCase analyze the parameters and select
+ * the appropriate "put" routine to use.
*/
#define REPEAT8(op) REPEAT4(op); REPEAT4(op)
#define REPEAT4(op) REPEAT2(op); REPEAT2(op)
@@ -1236,6 +1222,26 @@ DECLAREContigPutFunc(putRGBcontig8bittile)
}
}
+/*
+ * 8-bit packed samples, w/ Map => RGB
+ */
+DECLAREContigPutFunc(putRGBcontig8bitMaptile)
+{
+ TIFFRGBValue* Map = img->Map;
+ int samplesperpixel = img->samplesperpixel;
+
+ (void) y;
+ fromskew *= samplesperpixel;
+ while (h-- > 0) {
+ for (x = w; x-- > 0;) {
+ *cp++ = PACK(Map[pp[0]], Map[pp[1]], Map[pp[2]]);
+ pp += samplesperpixel;
+ }
+ pp += fromskew;
+ cp += toskew;
+ }
+}
+
/*
* 8-bit packed samples => RGBA w/ associated alpha
* (known to have Map == NULL)
@@ -1261,22 +1267,23 @@ DECLAREContigPutFunc(putRGBAAcontig8bittile)
*/
DECLAREContigPutFunc(putRGBUAcontig8bittile)
{
- int samplesperpixel = img->samplesperpixel;
- (void) y;
- fromskew *= samplesperpixel;
- while (h-- > 0) {
- uint32 r, g, b, a;
- 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;
- *cp++ = PACK4(r,g,b,a);
- pp += samplesperpixel;
- }
- cp += toskew;
- pp += fromskew;
+ int samplesperpixel = img->samplesperpixel;
+
+ (void) y;
+ fromskew *= samplesperpixel;
+ while (h-- > 0) {
+ uint32 r, g, b, a;
+ for (x = w; x-- > 0;) {
+ a = pp[3];
+ r = (pp[0] * a) / 255;
+ g = (pp[1] * a) / 255;
+ b = (pp[2] * a) / 255;
+ *cp++ = PACK4(r,g,b,a);
+ pp += samplesperpixel;
}
+ cp += toskew;
+ pp += fromskew;
+ }
}
/*
@@ -1284,18 +1291,19 @@ DECLAREContigPutFunc(putRGBUAcontig8bittile)
*/
DECLAREContigPutFunc(putRGBcontig16bittile)
{
- int samplesperpixel = img->samplesperpixel;
- uint16 *wp = (uint16 *)pp;
- (void) y;
- fromskew *= samplesperpixel;
- while (h-- > 0) {
- for (x = w; x-- > 0;) {
- *cp++ = PACKW(wp[0],wp[1],wp[2]);
- wp += samplesperpixel;
- }
- cp += toskew;
- wp += fromskew;
+ int samplesperpixel = img->samplesperpixel;
+ uint16 *wp = (uint16 *)pp;
+
+ (void) y;
+ fromskew *= samplesperpixel;
+ while (h-- > 0) {
+ for (x = w; x-- > 0;) {
+ *cp++ = PACKW(wp[0], wp[1], wp[2]);
+ wp += samplesperpixel;
}
+ cp += toskew;
+ wp += fromskew;
+ }
}
/*
@@ -1304,18 +1312,19 @@ DECLAREContigPutFunc(putRGBcontig16bittile)
*/
DECLAREContigPutFunc(putRGBAAcontig16bittile)
{
- int samplesperpixel = img->samplesperpixel;
- uint16 *wp = (uint16 *)pp;
- (void) y;
- fromskew *= samplesperpixel;
- while (h-- > 0) {
- for (x = w; x-- > 0;) {
- *cp++ = PACKW4(wp[0],wp[1],wp[2],wp[3]);
- wp += samplesperpixel;
- }
- cp += toskew;
- wp += fromskew;
+ int samplesperpixel = img->samplesperpixel;
+ uint16 *wp = (uint16 *)pp;
+
+ (void) y;
+ fromskew *= samplesperpixel;
+ while (h-- > 0) {
+ for (x = w; x-- > 0;) {
+ *cp++ = PACKW4(wp[0], wp[1], wp[2], wp[3]);
+ wp += samplesperpixel;
}
+ cp += toskew;
+ wp += fromskew;
+ }
}
/*
@@ -1324,23 +1333,32 @@ DECLAREContigPutFunc(putRGBAAcontig16bittile)
*/
DECLAREContigPutFunc(putRGBUAcontig16bittile)
{
- int samplesperpixel = img->samplesperpixel;
- uint16 *wp = (uint16 *)pp;
- (void) y;
- fromskew *= samplesperpixel;
- while (h-- > 0) {
- uint32 r,g,b,a;
- 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;
- }
- cp += toskew;
- wp += fromskew;
+ int samplesperpixel = img->samplesperpixel;
+ uint16 *wp = (uint16 *)pp;
+
+ (void) y;
+ fromskew *= samplesperpixel;
+ while (h-- > 0) {
+ uint32 r,g,b,a;
+ /*
+ * We shift alpha down four bits just in case unsigned
+ * arithmetic doesn't handle the full range.
+ * We still have plenty of accuracy, since the output is 8 bits.
+ * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff)
+ * Since we want r*a * 0xff for eight bit output,
+ * we divide by (0xffff * 0xfff) / 0xff == 0x10eff.
+ */
+ for (x = w; x-- > 0;) {
+ a = wp[3] >> 4;
+ r = (wp[0] * a) / 0x10eff;
+ g = (wp[1] * a) / 0x10eff;
+ b = (wp[2] * a) / 0x10eff;
+ *cp++ = PACK4(r,g,b,a);
+ wp += samplesperpixel;
}
+ cp += toskew;
+ wp += fromskew;
+ }
}
/*
@@ -1418,17 +1436,33 @@ DECLARESepPutFunc(putRGBseparate8bittile)
}
}
+/*
+ * 8-bit unpacked samples => RGB
+ */
+DECLARESepPutFunc(putRGBseparate8bitMaptile)
+{
+ TIFFRGBValue* Map = img->Map;
+
+ (void) y; (void) a;
+ while (h-- > 0) {
+ for (x = w; x > 0; x--)
+ *cp++ = PACK(Map[*r++], Map[*g++], Map[*b++]);
+ SKEW(r, g, b, fromskew);
+ cp += toskew;
+ }
+}
+
/*
* 8-bit unpacked samples => RGBA w/ associated alpha
*/
DECLARESepPutFunc(putRGBAAseparate8bittile)
{
- (void) img; (void) x; (void) y;
- while (h-- > 0) {
- UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
- SKEW4(r, g, b, a, fromskew);
- cp += toskew;
- }
+ (void) img; (void) x; (void) y;
+ while (h-- > 0) {
+ UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
+ SKEW4(r, g, b, a, fromskew);
+ cp += toskew;
+ }
}
/*
@@ -1436,19 +1470,19 @@ DECLARESepPutFunc(putRGBAAseparate8bittile)
*/
DECLARESepPutFunc(putRGBUAseparate8bittile)
{
- (void) img; (void) y;
- while (h-- > 0) {
- uint32 rv, gv, bv, av;
- for (x = w; x-- > 0;) {
- av = *a++;
- rv = (av* *r++ + 127) / 255;
- gv = (av* *g++ + 127) / 255;
- bv = (av* *b++ + 127) / 255;
- *cp++ = PACK4(rv,gv,bv,av);
- }
- SKEW4(r, g, b, a, fromskew);
- cp += toskew;
+ (void) img; (void) y;
+ while (h-- > 0) {
+ uint32 rv, gv, bv, av;
+ for (x = w; x-- > 0;) {
+ av = *a++;
+ rv = (*r++ * av) / 255;
+ gv = (*g++ * av) / 255;
+ bv = (*b++ * av) / 255;
+ *cp++ = PACK4(rv,gv,bv,av);
}
+ SKEW4(r, g, b, a, fromskew);
+ cp += toskew;
+ }
}
/*
@@ -1456,16 +1490,17 @@ DECLARESepPutFunc(putRGBUAseparate8bittile)
*/
DECLARESepPutFunc(putRGBseparate16bittile)
{
- uint16 *wr = (uint16*) r;
- uint16 *wg = (uint16*) g;
- uint16 *wb = (uint16*) b;
- (void) img; (void) y; (void) a;
- while (h-- > 0) {
- for (x = 0; x < w; x++)
- *cp++ = PACKW(*wr++,*wg++,*wb++);
- SKEW(wr, wg, wb, fromskew);
- cp += toskew;
- }
+ uint16 *wr = (uint16*) r;
+ uint16 *wg = (uint16*) g;
+ uint16 *wb = (uint16*) b;
+
+ (void) img; (void) y; (void) a;
+ while (h-- > 0) {
+ for (x = 0; x < w; x++)
+ *cp++ = PACKW(*wr++, *wg++, *wb++);
+ SKEW(wr, wg, wb, fromskew);
+ cp += toskew;
+ }
}
/*
@@ -1473,17 +1508,18 @@ DECLARESepPutFunc(putRGBseparate16bittile)
*/
DECLARESepPutFunc(putRGBAAseparate16bittile)
{
- uint16 *wr = (uint16*) r;
- uint16 *wg = (uint16*) g;
- uint16 *wb = (uint16*) b;
- uint16 *wa = (uint16*) a;
- (void) img; (void) y;
- while (h-- > 0) {
- for (x = 0; x < w; x++)
- *cp++ = PACKW4(*wr++,*wg++,*wb++,*wa++);
- SKEW4(wr, wg, wb, wa, fromskew);
- cp += toskew;
- }
+ uint16 *wr = (uint16*) r;
+ uint16 *wg = (uint16*) g;
+ uint16 *wb = (uint16*) b;
+ uint16 *wa = (uint16*) a;
+
+ (void) img; (void) y;
+ while (h-- > 0) {
+ for (x = 0; x < w; x++)
+ *cp++ = PACKW4(*wr++, *wg++, *wb++, *wa++);
+ SKEW4(wr, wg, wb, wa, fromskew);
+ cp += toskew;
+ }
}
/*
@@ -1491,23 +1527,32 @@ DECLARESepPutFunc(putRGBAAseparate16bittile)
*/
DECLARESepPutFunc(putRGBUAseparate16bittile)
{
- uint16 *wr = (uint16*) r;
- uint16 *wg = (uint16*) g;
- uint16 *wb = (uint16*) b;
- uint16 *wa = (uint16*) a;
- (void) img; (void) y;
- while (h-- > 0) {
- uint32 r,g,b,a;
- 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);
- }
- SKEW4(wr, wg, wb, wa, fromskew);
- cp += toskew;
+ uint16 *wr = (uint16*) r;
+ uint16 *wg = (uint16*) g;
+ uint16 *wb = (uint16*) b;
+ uint16 *wa = (uint16*) a;
+
+ (void) img; (void) y;
+ while (h-- > 0) {
+ uint32 r,g,b,a;
+ /*
+ * We shift alpha down four bits just in case unsigned
+ * arithmetic doesn't handle the full range.
+ * We still have plenty of accuracy, since the output is 8 bits.
+ * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff)
+ * Since we want r*a * 0xff for eight bit output,
+ * we divide by (0xffff * 0xfff) / 0xff == 0x10eff.
+ */
+ for (x = w; x-- > 0;) {
+ a = *wa++ >> 4;
+ r = (*wr++ * a) / 0x10eff;
+ g = (*wg++ * a) / 0x10eff;
+ b = (*wb++ * a) / 0x10eff;
+ *cp++ = PACK4(r,g,b,a);
}
+ SKEW4(wr, wg, wb, wa, fromskew);
+ cp += toskew;
+ }
}
/*
@@ -1845,56 +1890,63 @@ DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
*/
DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
{
- uint32* cp2;
- (void) y;
- fromskew = (fromskew / 2) * 6;
- cp2 = cp+w+toskew;
- while (h>=2) {
- x = w;
- while (x>=2) {
- uint32 Cb = pp[4];
- uint32 Cr = pp[5];
- YCbCrtoRGB(cp[0], pp[0]);
- YCbCrtoRGB(cp[1], pp[1]);
- YCbCrtoRGB(cp2[0], pp[2]);
- YCbCrtoRGB(cp2[1], pp[3]);
- cp += 2;
- cp2 += 2;
- pp += 6;
- x -= 2;
- }
- if (x==1) {
- uint32 Cb = pp[4];
- uint32 Cr = pp[5];
- YCbCrtoRGB(cp[0], pp[0]);
- YCbCrtoRGB(cp2[0], pp[2]);
- cp ++ ;
- cp2 ++ ;
- pp += 6;
- }
- cp += toskew*2+w;
- cp2 += toskew*2+w;
- pp += fromskew;
- h-=2;
- }
- if (h==1) {
- x = w;
- while (x>=2) {
- uint32 Cb = pp[4];
- uint32 Cr = pp[5];
- YCbCrtoRGB(cp[0], pp[0]);
- YCbCrtoRGB(cp[1], pp[1]);
- cp += 2;
- cp2 += 2;
- pp += 6;
- x -= 2;
- }
- if (x==1) {
- uint32 Cb = pp[4];
- uint32 Cr = pp[5];
- YCbCrtoRGB(cp[0], pp[0]);
- }
- }
+ uint32* cp1 = cp+w+toskew;
+ int32 incr = 2*toskew+w;
+
+ (void) y;
+ fromskew = (fromskew * 6) / 2;
+ if ((h & 1) == 0 && (w & 1) == 0) {
+ for (; h >= 2; h -= 2) {
+ x = w>>1;
+ do {
+ int32 Cb = pp[4];
+ int32 Cr = pp[5];
+
+ YCbCrtoRGB(cp [0], pp[0]);
+ YCbCrtoRGB(cp [1], pp[1]);
+ YCbCrtoRGB(cp1[0], pp[2]);
+ YCbCrtoRGB(cp1[1], pp[3]);
+
+ cp += 2, cp1 += 2;
+ pp += 6;
+ } while (--x);
+ cp += incr, cp1 += incr;
+ pp += fromskew;
+ }
+ } else {
+ while (h > 0) {
+ for (x = w; x > 0;) {
+ int32 Cb = pp[4];
+ int32 Cr = pp[5];
+ switch (x) {
+ default:
+ switch (h) {
+ default: YCbCrtoRGB(cp1[1], pp[ 3]); /* FALLTHROUGH */
+ case 1: YCbCrtoRGB(cp [1], pp[ 1]); /* FALLTHROUGH */
+ } /* FALLTHROUGH */
+ case 1:
+ switch (h) {
+ default: YCbCrtoRGB(cp1[0], pp[ 2]); /* FALLTHROUGH */
+ case 1: YCbCrtoRGB(cp [0], pp[ 0]); /* FALLTHROUGH */
+ } /* FALLTHROUGH */
+ }
+ if (x < 2) {
+ cp += x; cp1 += x;
+ x = 0;
+ }
+ else {
+ cp += 2; cp1 += 2;
+ x -= 2;
+ }
+ pp += 6;
+ }
+ if (h <= 2)
+ break;
+ h -= 2;
+ cp += incr, cp1 += incr;
+ pp += fromskew;
+ }
+ }
}
/*
@@ -1902,72 +1954,35 @@ DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
*/
DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
{
- (void) y;
- fromskew = (fromskew * 4) / 2;
+ (void) y;
+ fromskew = (fromskew * 4) / 2;
+ do {
+ x = w>>1;
do {
- x = w>>1;
- do {
- int32 Cb = pp[2];
- int32 Cr = pp[3];
-
- YCbCrtoRGB(cp[0], pp[0]);
- YCbCrtoRGB(cp[1], pp[1]);
+ int32 Cb = pp[2];
+ int32 Cr = pp[3];
- cp += 2;
- pp += 4;
- } while (--x);
+ YCbCrtoRGB(cp[0], pp[0]);
+ YCbCrtoRGB(cp[1], pp[1]);
- if( (w&1) != 0 )
- {
- int32 Cb = pp[2];
- int32 Cr = pp[3];
-
- YCbCrtoRGB(cp[0], pp[0]);
+ cp += 2;
+ pp += 4;
+ } while (--x);
- cp += 1;
- pp += 4;
- }
+ if( (w&1) != 0 )
+ {
+ int32 Cb = pp[2];
+ int32 Cr = pp[3];
+
+ YCbCrtoRGB(cp [0], pp[0]);
- cp += toskew;
- pp += fromskew;
- } while (--h);
-}
+ cp += 1;
+ pp += 4;
+ }
-/*
- * 8-bit packed YCbCr samples w/ 1,2 subsampling => RGB
- */
-DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
-{
- uint32* cp2;
- (void) y;
- fromskew = (fromskew / 2) * 4;
- cp2 = cp+w+toskew;
- while (h>=2) {
- x = w;
- do {
- uint32 Cb = pp[2];
- uint32 Cr = pp[3];
- YCbCrtoRGB(cp[0], pp[0]);
- YCbCrtoRGB(cp2[0], pp[1]);
- cp ++;
- cp2 ++;
- pp += 4;
- } while (--x);
- cp += toskew*2+w;
- cp2 += toskew*2+w;
- pp += fromskew;
- h-=2;
- }
- if (h==1) {
- x = w;
- do {
- uint32 Cb = pp[2];
- uint32 Cr = pp[3];
- YCbCrtoRGB(cp[0], pp[0]);
- cp ++;
- pp += 4;
- } while (--x);
- }
+ cp += toskew;
+ pp += fromskew;
+ } while (--h);
}
/*
@@ -1975,71 +1990,70 @@ DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
*/
DECLAREContigPutFunc(putcontig8bitYCbCr11tile)
{
- (void) y;
- fromskew *= 3;
+ (void) y;
+ fromskew *= 3;
+ do {
+ x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */
do {
- x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */
- do {
- int32 Cb = pp[1];
- int32 Cr = pp[2];
+ int32 Cb = pp[1];
+ int32 Cr = pp[2];
- YCbCrtoRGB(*cp++, pp[0]);
-
- pp += 3;
- } while (--x);
- cp += toskew;
- pp += fromskew;
- } while (--h);
-}
+ YCbCrtoRGB(*cp++, pp[0]);
-/*
- * 8-bit packed YCbCr samples w/ no subsampling => RGB
- */
-DECLARESepPutFunc(putseparate8bitYCbCr11tile)
-{
- (void) y;
- (void) a;
- /* TODO: naming of input vars is still off, change obfuscating declaration inside define, or resolve obfuscation */
- while (h-- > 0) {
- x = w;
- do {
- uint32 dr, dg, db;
- TIFFYCbCrtoRGB(img->ycbcr,*r++,*g++,*b++,&dr,&dg,&db);
- *cp++ = PACK(dr,dg,db);
- } while (--x);
- SKEW(r, g, b, fromskew);
- cp += toskew;
- }
+ pp += 3;
+ } while (--x);
+ cp += toskew;
+ pp += fromskew;
+ } while (--h);
}
-#undef YCbCrtoRGB
+#undef YCbCrtoRGB
-static int
+static tileContigRoutine
initYCbCrConversion(TIFFRGBAImage* img)
{
- static char module[] = "initYCbCrConversion";
+ static char module[] = "initCIELabConversion";
float *luma, *refBlackWhite;
+ uint16 hs, vs;
if (img->ycbcr == NULL) {
- img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc(
+ img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc(
TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))
+ 4*256*sizeof (TIFFRGBValue)
+ 2*256*sizeof (int)
+ 3*256*sizeof (int32)
- );
- if (img->ycbcr == NULL) {
+ );
+ if (img->ycbcr == NULL) {
TIFFErrorExt(img->tif->tif_clientdata, module,
- "No space for YCbCr->RGB conversion state");
- return (0);
- }
+ "No space for YCbCr->RGB conversion state");
+ return (NULL);
+ }
}
TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
TIFFGetFieldDefaulted(img->tif, TIFFTAG_REFERENCEBLACKWHITE,
- &refBlackWhite);
+ &refBlackWhite);
if (TIFFYCbCrToRGBInit(img->ycbcr, luma, refBlackWhite) < 0)
- return(0);
- return (1);
+ return NULL;
+
+ /*
+ * The 6.0 spec says that subsampling must be
+ * one of 1, 2, or 4, and that vertical subsampling
+ * must always be <= horizontal subsampling; so
+ * there are only a few possibilities and we just
+ * enumerate the cases.
+ */
+ TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs);
+ switch ((hs<<4)|vs) {
+ case 0x44: return (putcontig8bitYCbCr44tile);
+ case 0x42: return (putcontig8bitYCbCr42tile);
+ case 0x41: return (putcontig8bitYCbCr41tile);
+ case 0x22: return (putcontig8bitYCbCr22tile);
+ case 0x21: return (putcontig8bitYCbCr21tile);
+ case 0x11: return (putcontig8bitYCbCr11tile);
+ }
+
+ return (NULL);
}
static tileContigRoutine
@@ -2313,140 +2327,73 @@ buildMap(TIFFRGBAImage* img)
* Select the appropriate conversion routine for packed data.
*/
static int
-PickContigCase(TIFFRGBAImage* img)
+pickTileContigCase(TIFFRGBAImage* img)
{
- img->get = TIFFIsTiled(img->tif) ? gtTileContig : gtStripContig;
- img->put.contig = NULL;
+ tileContigRoutine put = 0;
+
+ if (buildMap(img)) {
switch (img->photometric) {
- case PHOTOMETRIC_RGB:
- switch (img->bitspersample) {
- case 8:
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
- img->put.contig = putRGBAAcontig8bittile;
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
- {
- img->put.contig = putRGBUAcontig8bittile;
- }
- else
- img->put.contig = putRGBcontig8bittile;
- break;
- case 16:
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
- {
- img->put.contig = putRGBAAcontig16bittile;
- }
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
- {
- img->put.contig = putRGBUAcontig16bittile;
- }
- else
- {
- img->put.contig = putRGBcontig16bittile;
- }
- break;
- }
- break;
- case PHOTOMETRIC_SEPARATED:
- if (buildMap(img)) {
- if (img->bitspersample == 8) {
- if (!img->Map)
- img->put.contig = putRGBcontig8bitCMYKtile;
- else
- img->put.contig = putRGBcontig8bitCMYKMaptile;
- }
- }
- break;
- case PHOTOMETRIC_PALETTE:
- if (buildMap(img)) {
- switch (img->bitspersample) {
- case 8:
- img->put.contig = put8bitcmaptile;
- break;
- case 4:
- img->put.contig = put4bitcmaptile;
- break;
- case 2:
- img->put.contig = put2bitcmaptile;
- break;
- case 1:
- img->put.contig = put1bitcmaptile;
- break;
- }
- }
- break;
- case PHOTOMETRIC_MINISWHITE:
- case PHOTOMETRIC_MINISBLACK:
- if (buildMap(img)) {
- switch (img->bitspersample) {
- case 16:
- img->put.contig = put16bitbwtile;
- break;
- case 8:
- img->put.contig = putgreytile;
- break;
- case 4:
- img->put.contig = put4bitbwtile;
- break;
- case 2:
- img->put.contig = put2bitbwtile;
- break;
- case 1:
- img->put.contig = put1bitbwtile;
- break;
- }
- }
- break;
- case PHOTOMETRIC_YCBCR:
- if (img->bitspersample == 8)
- {
- if (initYCbCrConversion(img)!=0)
- {
- /*
- * The 6.0 spec says that subsampling must be
- * one of 1, 2, or 4, and that vertical subsampling
- * must always be <= horizontal subsampling; so
- * there are only a few possibilities and we just
- * enumerate the cases.
- * Joris: added support for the [1,2] case, nonetheless, to accomodate
- * some OJPEG files
- */
- uint16 SubsamplingHor;
- uint16 SubsamplingVer;
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &SubsamplingHor, &SubsamplingVer);
- switch ((SubsamplingHor<<4)|SubsamplingVer) {
- case 0x44:
- img->put.contig = putcontig8bitYCbCr44tile;
- break;
- case 0x42:
- img->put.contig = putcontig8bitYCbCr42tile;
- break;
- case 0x41:
- img->put.contig = putcontig8bitYCbCr41tile;
- break;
- case 0x22:
- img->put.contig = putcontig8bitYCbCr22tile;
- break;
- case 0x21:
- img->put.contig = putcontig8bitYCbCr21tile;
- break;
- case 0x12:
- img->put.contig = putcontig8bitYCbCr12tile;
- break;
- case 0x11:
- img->put.contig = putcontig8bitYCbCr11tile;
- break;
- }
- }
- }
- break;
- case PHOTOMETRIC_CIELAB:
- if (buildMap(img)) {
- if (img->bitspersample == 8)
- img->put.contig = initCIELabConversion(img);
- break;
- }
+ case PHOTOMETRIC_RGB:
+ switch (img->bitspersample) {
+ case 8:
+ if (!img->Map) {
+ if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
+ put = putRGBAAcontig8bittile;
+ else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
+ put = putRGBUAcontig8bittile;
+ else
+ put = putRGBcontig8bittile;
+ } else
+ put = putRGBcontig8bitMaptile;
+ break;
+ case 16:
+ put = putRGBcontig16bittile;
+ if (!img->Map) {
+ if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
+ put = putRGBAAcontig16bittile;
+ else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
+ put = putRGBUAcontig16bittile;
+ }
+ break;
+ }
+ break;
+ case PHOTOMETRIC_SEPARATED:
+ if (img->bitspersample == 8) {
+ if (!img->Map)
+ put = putRGBcontig8bitCMYKtile;
+ else
+ put = putRGBcontig8bitCMYKMaptile;
+ }
+ break;
+ case PHOTOMETRIC_PALETTE:
+ switch (img->bitspersample) {
+ case 8: put = put8bitcmaptile; break;
+ case 4: put = put4bitcmaptile; break;
+ case 2: put = put2bitcmaptile; break;
+ case 1: put = put1bitcmaptile; break;
+ }
+ break;
+ case PHOTOMETRIC_MINISWHITE:
+ case PHOTOMETRIC_MINISBLACK:
+ switch (img->bitspersample) {
+ case 16: put = put16bitbwtile; break;
+ case 8: put = putgreytile; break;
+ case 4: put = put4bitbwtile; break;
+ case 2: put = put2bitbwtile; break;
+ case 1: put = put1bitbwtile; break;
+ }
+ break;
+ case PHOTOMETRIC_YCBCR:
+ if (img->bitspersample == 8)
+ put = initYCbCrConversion(img);
+ break;
+ case PHOTOMETRIC_CIELAB:
+ if (img->bitspersample == 8)
+ put = initCIELabConversion(img);
+ break;
}
- return ((img->get!=NULL) && (img->put.contig!=NULL));
+ }
+ return ((img->put.contig = put) != 0);
}
/*
@@ -2456,57 +2403,39 @@ PickContigCase(TIFFRGBAImage* img)
* to the "packed routines.
*/
static int
-PickSeparateCase(TIFFRGBAImage* img)
+pickTileSeparateCase(TIFFRGBAImage* img)
{
- img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate;
- img->put.separate = NULL;
+ tileSeparateRoutine put = 0;
+
+ if (buildMap(img)) {
switch (img->photometric) {
- case PHOTOMETRIC_RGB:
- switch (img->bitspersample) {
- case 8:
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
- img->put.separate = putRGBAAseparate8bittile;
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
- {
- img->put.separate = putRGBUAseparate8bittile;
- }
- else
- img->put.separate = putRGBseparate8bittile;
- break;
- case 16:
- if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
- {
- img->put.separate = putRGBAAseparate16bittile;
- }
- else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
- {
- img->put.separate = putRGBUAseparate16bittile;
- }
- else
- {
- img->put.separate = putRGBseparate16bittile;
- }
- break;
- }
- break;
- case PHOTOMETRIC_YCBCR:
- if ((img->bitspersample==8) && (img->samplesperpixel==3))
- {
- if (initYCbCrConversion(img)!=0)
- {
- uint16 hs, vs;
- TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs);
- switch ((hs<<4)|vs) {
- case 0x11:
- img->put.separate = putseparate8bitYCbCr11tile;
- break;
- /* TODO: add other cases here */
- }
- }
- }
- break;
+ case PHOTOMETRIC_RGB:
+ switch (img->bitspersample) {
+ case 8:
+ if (!img->Map) {
+ if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
+ put = putRGBAAseparate8bittile;
+ else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
+ put = putRGBUAseparate8bittile;
+ else
+ put = putRGBseparate8bittile;
+ } else
+ put = putRGBseparate8bitMaptile;
+ break;
+ case 16:
+ put = putRGBseparate16bittile;
+ if (!img->Map) {
+ if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
+ put = putRGBAAseparate16bittile;
+ else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
+ put = putRGBUAseparate16bittile;
+ }
+ break;
+ }
+ break;
}
- return ((img->get!=NULL) && (img->put.separate!=NULL));
+ }
+ return ((img->put.separate = put) != 0);
}
/*
@@ -2555,7 +2484,7 @@ TIFFReadRGBAStrip(TIFF* tif, uint32 row, uint32 * raster )
TIFFRGBAImageEnd(&img);
} else {
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
+ TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), emsg);
ok = 0;
}
@@ -2607,7 +2536,7 @@ TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster)
if (!TIFFRGBAImageOK(tif, emsg)
|| !TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
- TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
+ TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), emsg);
return( 0 );
}
diff --git a/src/libtiff/tif_jpeg.c b/src/libtiff/tif_jpeg.c
index 0068ad9..6a8ebea 100644
--- a/src/libtiff/tif_jpeg.c
+++ b/src/libtiff/tif_jpeg.c
@@ -1,4 +1,4 @@
-/* $Id: tif_jpeg.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_jpeg.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1994-1997 Sam Leffler
@@ -154,7 +154,6 @@ typedef struct {
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
- TIFFPrintMethod printdir; /* super-class method */
TIFFStripMethod defsparent; /* super-class method */
TIFFTileMethod deftparent; /* super-class method */
/* pseudo-tag fields */
@@ -228,7 +227,7 @@ TIFFjpeg_error_exit(j_common_ptr cinfo)
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message) (cinfo, buffer);
- TIFFErrorExt(sp->tif->tif_clientdata, "JPEGLib", "%s", buffer); /* display the error message */
+ TIFFErrorExt(sp->tif->tif_clientdata, "JPEGLib", buffer); /* display the error message */
jpeg_abort(cinfo); /* clean up libjpeg state */
LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
}
@@ -244,7 +243,7 @@ TIFFjpeg_output_message(j_common_ptr cinfo)
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message) (cinfo, buffer);
- TIFFWarningExt(((JPEGState *) cinfo)->tif->tif_clientdata, "JPEGLib", "%s", buffer);
+ TIFFWarningExt(((JPEGState *) cinfo)->tif->tif_clientdata, "JPEGLib", buffer);
}
/*
@@ -715,7 +714,7 @@ JPEGPreDecode(TIFF* tif, tsample_t s)
} else {
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
- sp->bytesperline = TIFFOldScanlineSize(tif);
+ sp->bytesperline = TIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
/*
@@ -725,29 +724,14 @@ JPEGPreDecode(TIFF* tif, tsample_t s)
segment_width = TIFFhowmany(segment_width, sp->h_sampling);
segment_height = TIFFhowmany(segment_height, sp->v_sampling);
}
- if (sp->cinfo.d.image_width < segment_width ||
- sp->cinfo.d.image_height < segment_height) {
+ if (sp->cinfo.d.image_width != segment_width ||
+ sp->cinfo.d.image_height != segment_height) {
TIFFWarningExt(tif->tif_clientdata, module,
- "Improper JPEG strip/tile size, "
- "expected %dx%d, got %dx%d",
- segment_width, segment_height,
- sp->cinfo.d.image_width,
- sp->cinfo.d.image_height);
- }
- if (sp->cinfo.d.image_width > segment_width ||
- sp->cinfo.d.image_height > segment_height) {
- /*
- * This case could be dangerous, if the strip or tile size has
- * been reported as less than the amount of data jpeg will
- * return, some potential security issues arise. Catch this
- * case and error out.
- */
- TIFFErrorExt(tif->tif_clientdata, module,
- "JPEG strip/tile size exceeds expected dimensions,"
- " expected %dx%d, got %dx%d",
- segment_width, segment_height,
- sp->cinfo.d.image_width, sp->cinfo.d.image_height);
- return (0);
+ "Improper JPEG strip/tile size, expected %dx%d, got %dx%d",
+ segment_width,
+ segment_height,
+ sp->cinfo.d.image_width,
+ sp->cinfo.d.image_height);
}
if (sp->cinfo.d.num_components !=
(td->td_planarconfig == PLANARCONFIG_CONTIG ?
@@ -779,24 +763,6 @@ JPEGPreDecode(TIFF* tif, tsample_t s)
sp->cinfo.d.comp_info[0].v_samp_factor,
sp->h_sampling, sp->v_sampling);
- /*
- * There are potential security issues here
- * for decoders that have already allocated
- * buffers based on the expected sampling
- * factors. Lets check the sampling factors
- * dont exceed what we were expecting.
- */
- if (sp->cinfo.d.comp_info[0].h_samp_factor
- > sp->h_sampling
- || sp->cinfo.d.comp_info[0].v_samp_factor
- > sp->v_sampling) {
- TIFFErrorExt(tif->tif_clientdata,
- module,
- "Cannot honour JPEG sampling factors"
- " that exceed those specified.");
- return (0);
- }
-
/*
* XXX: Files written by the Intergraph software
* has different sampling factors stored in the
@@ -844,9 +810,10 @@ JPEGPreDecode(TIFF* tif, tsample_t s)
/* Suppress colorspace handling */
sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
sp->cinfo.d.out_color_space = JCS_UNKNOWN;
+ tif->tif_flags |= TIFF_UPSAMPLED; /* IMLIB - allow upsampling when there is no colorspace handling
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
(sp->h_sampling != 1 || sp->v_sampling != 1))
- downsampled_output = TRUE;
+ downsampled_output = TRUE; */
/* XXX what about up-sampling? */
}
if (downsampled_output) {
@@ -986,121 +953,119 @@ JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
/*ARGSUSED*/ static int
JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
{
- JPEGState *sp = JState(tif);
- tsize_t nrows;
- (void) s;
-
- /* data is expected to be read in multiples of a scanline */
- if ( (nrows = sp->cinfo.d.image_height) ) {
- /* Cb,Cr both have sampling factors 1, so this is correct */
- JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
- int samples_per_clump = sp->samplesperclump;
+ JPEGState *sp = JState(tif);
+ tsize_t nrows;
+ (void) s;
+ /* data is expected to be read in multiples of a scanline */
+ if ( (nrows = sp->cinfo.d.image_height) ) {
+ /* Cb,Cr both have sampling factors 1, so this is correct */
+ JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
+ int samples_per_clump = sp->samplesperclump;
+
#ifdef JPEG_LIB_MK1
- unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) *
- sp->cinfo.d.output_width *
- sp->cinfo.d.num_components);
+ unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) *
+ sp->cinfo.d.output_width *
+ sp->cinfo.d.num_components);
#endif
-
- do {
- jpeg_component_info *compptr;
- int ci, clumpoffset;
-
- /* Reload downsampled-data buffer if needed */
- if (sp->scancount >= DCTSIZE) {
- int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
- if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)
- return (0);
- sp->scancount = 0;
- }
- /*
- * Fastest way to unseparate data is to make one pass
- * over the scanline for each row of each component.
- */
- clumpoffset = 0; /* first sample in clump */
- for (ci = 0, compptr = sp->cinfo.d.comp_info;
- ci < sp->cinfo.d.num_components;
- ci++, compptr++) {
- int hsamp = compptr->h_samp_factor;
- int vsamp = compptr->v_samp_factor;
- int ypos;
-
- for (ypos = 0; ypos < vsamp; ypos++) {
- JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
+
+ do {
+ jpeg_component_info *compptr;
+ int ci, clumpoffset;
+
+ /* Reload downsampled-data buffer if needed */
+ if (sp->scancount >= DCTSIZE) {
+ int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
+ if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n)
+ != n)
+ return (0);
+ sp->scancount = 0;
+ }
+ /*
+ * Fastest way to unseparate data is to make one pass
+ * over the scanline for each row of each component.
+ */
+ clumpoffset = 0; /* first sample in clump */
+ for (ci = 0, compptr = sp->cinfo.d.comp_info;
+ ci < sp->cinfo.d.num_components;
+ ci++, compptr++) {
+ int hsamp = compptr->h_samp_factor;
+ int vsamp = compptr->v_samp_factor;
+ int ypos;
+
+ for (ypos = 0; ypos < vsamp; ypos++) {
+ JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
#ifdef JPEG_LIB_MK1
- JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset;
+ JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset;
#else
- JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;
+ JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;
#endif
- JDIMENSION nclump;
-
- if (hsamp == 1) {
- /* fast path for at least Cb and Cr */
- for (nclump = clumps_per_line; nclump-- > 0; ) {
- outptr[0] = *inptr++;
- outptr += samples_per_clump;
- }
- } else {
- int xpos;
-
- /* general case */
- for (nclump = clumps_per_line; nclump-- > 0; ) {
- for (xpos = 0; xpos < hsamp; xpos++)
- outptr[xpos] = *inptr++;
- outptr += samples_per_clump;
- }
- }
- clumpoffset += hsamp;
- }
- }
+ JDIMENSION nclump;
+
+ if (hsamp == 1) {
+ /* fast path for at least Cb and Cr */
+ for (nclump = clumps_per_line; nclump-- > 0; ) {
+ outptr[0] = *inptr++;
+ outptr += samples_per_clump;
+ }
+ } else {
+ int xpos;
+
+ /* general case */
+ for (nclump = clumps_per_line; nclump-- > 0; ) {
+ for (xpos = 0; xpos < hsamp; xpos++)
+ outptr[xpos] = *inptr++;
+ outptr += samples_per_clump;
+ }
+ }
+ clumpoffset += hsamp;
+ }
+ }
#ifdef JPEG_LIB_MK1
- {
- if (sp->cinfo.d.data_precision == 8)
- {
- int i=0;
- int len = sp->cinfo.d.output_width * sp->cinfo.d.num_components;
- for (i=0; i<len; i++)
- {
- ((unsigned char*)buf)[i] = tmpbuf[i] & 0xff;
- }
- }
- else
- { // 12-bit
- int value_pairs = (sp->cinfo.d.output_width
- * sp->cinfo.d.num_components) / 2;
- int iPair;
- for( iPair = 0; iPair < value_pairs; iPair++ )
- {
- unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3;
- JSAMPLE *in_ptr = tmpbuf + iPair * 2;
- out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
- out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
- | ((in_ptr[1] & 0xf00) >> 8);
- out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
- }
- }
- }
+ {
+ if (sp->cinfo.d.data_precision == 8)
+ {
+ int i=0;
+ int len = sp->cinfo.d.output_width * sp->cinfo.d.num_components;
+ for (i=0; i<len; i++)
+ {
+ ((unsigned char*)buf)[i] = tmpbuf[i] & 0xff;
+ }
+ }
+ else
+ { // 12-bit
+ int value_pairs = (sp->cinfo.d.output_width
+ * sp->cinfo.d.num_components) / 2;
+ int iPair;
+ for( iPair = 0; iPair < value_pairs; iPair++ )
+ {
+ unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3;
+ JSAMPLE *in_ptr = tmpbuf + iPair * 2;
+ out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
+ out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
+ | ((in_ptr[1] & 0xf00) >> 8);
+ out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
+ }
+ }
+ }
#endif
- sp->scancount ++;
- tif->tif_row += sp->v_sampling;
- /* increment/decrement of buf and cc is still incorrect, but should not matter
- * TODO: resolve this */
- buf += sp->bytesperline;
- cc -= sp->bytesperline;
- nrows -= sp->v_sampling;
- } while (nrows > 0);
-
+ ++sp->scancount;
+ ++tif->tif_row;
+ buf += sp->bytesperline;
+ cc -= sp->bytesperline;
+ } while (--nrows > 0);
+
#ifdef JPEG_LIB_MK1
- _TIFFfree(tmpbuf);
+ _TIFFfree(tmpbuf);
#endif
- }
+ }
- /* Close down the decompressor if done. */
- return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
- || TIFFjpeg_finish_decompress(sp);
+ /* Close down the decompressor if done. */
+ return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
+ || TIFFjpeg_finish_decompress(sp);
}
@@ -1235,9 +1200,9 @@ JPEGSetupEncode(TIFF* tif)
/* BITS_IN_JSAMPLE now permits 8 and 12 --- dgilbert */
if (td->td_bitspersample != 8 && td->td_bitspersample != 12)
#else
- if (td->td_bitspersample != BITS_IN_JSAMPLE )
+ if (td->td_bitspersample != BITS_IN_JSAMPLE )
#endif
- {
+ {
TIFFErrorExt(tif->tif_clientdata, module, "BitsPerSample %d not allowed for JPEG",
(int) td->td_bitspersample);
return (0);
@@ -1315,7 +1280,7 @@ JPEGPreEncode(TIFF* tif, tsample_t s)
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
- sp->bytesperline = TIFFOldScanlineSize(tif);
+ sp->bytesperline = TIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
/* for PC 2, scale down the strip/tile size
@@ -1338,8 +1303,9 @@ JPEGPreEncode(TIFF* tif, tsample_t s)
sp->cinfo.c.in_color_space = JCS_RGB;
} else {
sp->cinfo.c.in_color_space = JCS_YCbCr;
+ tif->tif_flags |= TIFF_UPSAMPLED; /* IMLIB - allow upsampling in the input data
if (sp->h_sampling != 1 || sp->v_sampling != 1)
- downsampled_input = TRUE;
+ downsampled_input = TRUE; */
}
if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
return (0);
@@ -1427,10 +1393,6 @@ JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
if (cc % sp->bytesperline)
TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");
- /* The last strip will be limited to image size */
- if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength )
- nrows = tif->tif_dir.td_imagelength - tif->tif_row;
-
while (nrows-- > 0) {
bufptr[0] = (JSAMPROW) buf;
if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
@@ -1457,25 +1419,18 @@ JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
int clumpoffset, ci, xpos, ypos;
jpeg_component_info* compptr;
int samples_per_clump = sp->samplesperclump;
- tsize_t bytesperclumpline;
(void) s;
assert(sp != NULL);
- /* data is expected to be supplied in multiples of a clumpline */
- /* a clumpline is equivalent to v_sampling desubsampled scanlines */
- /* TODO: the following calculation of bytesperclumpline, should substitute calculation of sp->bytesperline, except that it is per v_sampling lines */
- bytesperclumpline = (((sp->cinfo.c.image_width+sp->h_sampling-1)/sp->h_sampling)
- *(sp->h_sampling*sp->v_sampling+2)*sp->cinfo.c.data_precision+7)
- /8;
-
- nrows = ( cc / bytesperclumpline ) * sp->v_sampling;
- if (cc % bytesperclumpline)
+ /* data is expected to be supplied in multiples of a scanline */
+ nrows = cc / sp->bytesperline;
+ if (cc % sp->bytesperline)
TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");
/* Cb,Cr both have sampling factors 1, so this is correct */
clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
- while (nrows > 0) {
+ while (nrows-- > 0) {
/*
* Fastest way to separate the data is to make one pass
* over the scanline for each row of each component.
@@ -1520,9 +1475,9 @@ JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
return (0);
sp->scancount = 0;
}
- tif->tif_row += sp->v_sampling;
+ if (nrows > 0)
+ tif->tif_row++;
buf += sp->bytesperline;
- nrows -= sp->v_sampling;
}
return (1);
}
@@ -1574,7 +1529,6 @@ JPEGCleanup(TIFF* tif)
tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent;
- tif->tif_tagmethods.printdir = sp->printdir;
if( sp->cinfo_initialized )
TIFFjpeg_destroy(sp); /* release libjpeg resources */
@@ -1586,43 +1540,11 @@ JPEGCleanup(TIFF* tif)
_TIFFSetDefaultCompressionState(tif);
}
-static void
-JPEGResetUpsampled( TIFF* tif )
-{
- JPEGState* sp = JState(tif);
- TIFFDirectory* td = &tif->tif_dir;
-
- /*
- * Mark whether returned data is up-sampled or not so TIFFStripSize
- * and TIFFTileSize return values that reflect the true amount of
- * data.
- */
- tif->tif_flags &= ~TIFF_UPSAMPLED;
- if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
- if (td->td_photometric == PHOTOMETRIC_YCBCR &&
- sp->jpegcolormode == JPEGCOLORMODE_RGB) {
- tif->tif_flags |= TIFF_UPSAMPLED;
- } else {
-#ifdef notdef
- if (td->td_ycbcrsubsampling[0] != 1 ||
- td->td_ycbcrsubsampling[1] != 1)
- ; /* XXX what about up-sampling? */
-#endif
- }
- }
-
- /*
- * Must recalculate cached tile size in case sampling state changed.
- * Should we really be doing this now if image size isn't set?
- */
- tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
-}
-
static int
JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
{
JPEGState* sp = JState(tif);
- const TIFFFieldInfo* fip;
+ TIFFDirectory* td = &tif->tif_dir;
uint32 v32;
assert(sp != NULL);
@@ -1644,21 +1566,34 @@ JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
return (1); /* pseudo tag */
case TIFFTAG_JPEGCOLORMODE:
sp->jpegcolormode = va_arg(ap, int);
- JPEGResetUpsampled( tif );
+ /*
+ * Mark whether returned data is up-sampled or not
+ * so TIFFStripSize and TIFFTileSize return values
+ * that reflect the true amount of data.
+ */
+ tif->tif_flags &= ~TIFF_UPSAMPLED;
+ if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
+ if (td->td_photometric == PHOTOMETRIC_YCBCR &&
+ sp->jpegcolormode == JPEGCOLORMODE_RGB) {
+ tif->tif_flags |= TIFF_UPSAMPLED;
+ } else {
+ if (td->td_ycbcrsubsampling[0] != 1 ||
+ td->td_ycbcrsubsampling[1] != 1)
+ ; /* XXX what about up-sampling? */
+ }
+ }
+ /*
+ * Must recalculate cached tile size
+ * in case sampling state changed.
+ */
+ tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
return (1); /* pseudo tag */
- case TIFFTAG_PHOTOMETRIC:
- {
- int ret_value = (*sp->vsetparent)(tif, tag, ap);
- JPEGResetUpsampled( tif );
- return ret_value;
- }
case TIFFTAG_JPEGTABLESMODE:
sp->jpegtablesmode = va_arg(ap, int);
return (1); /* pseudo tag */
case TIFFTAG_YCBCRSUBSAMPLING:
/* mark the fact that we have a real ycbcrsubsampling! */
sp->ycbcrsampling_fetched = 1;
- /* should we be recomputing upsampling info here? */
return (*sp->vsetparent)(tif, tag, ap);
case TIFFTAG_FAXRECVPARAMS:
sp->recvparams = va_arg(ap, uint32);
@@ -1675,13 +1610,7 @@ JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
default:
return (*sp->vsetparent)(tif, tag, ap);
}
-
- if ((fip = _TIFFFieldWithTag(tif, tag))) {
- TIFFSetFieldBit(tif, fip->field_bit);
- } else {
- return (0);
- }
-
+ TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
tif->tif_flags |= TIFF_DIRTYDIRECT;
return (1);
}
@@ -1777,6 +1706,7 @@ JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
case TIFFTAG_YCBCRSUBSAMPLING:
JPEGFixupTestSubsampling( tif );
return (*sp->vgetparent)(tif, tag, ap);
+ break;
case TIFFTAG_FAXRECVPARAMS:
*va_arg(ap, uint32*) = sp->recvparams;
break;
@@ -1870,18 +1800,8 @@ static int JPEGInitializeLibJPEG( TIFF * tif, int force_encode, int force_decode
int data_is_empty = TRUE;
int decompress;
-
- if(sp->cinfo_initialized)
- {
- if( force_encode && sp->cinfo.comm.is_decompressor )
- TIFFjpeg_destroy( sp );
- else if( force_decode && !sp->cinfo.comm.is_decompressor )
- TIFFjpeg_destroy( sp );
- else
- return 1;
-
- sp->cinfo_initialized = 0;
- }
+ if( sp->cinfo_initialized )
+ return 1;
/*
* Do we have tile data already? Make sure we initialize the
@@ -1936,39 +1856,29 @@ TIFFInitJPEG(TIFF* tif, int scheme)
assert(scheme == COMPRESSION_JPEG);
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata,
- "TIFFInitJPEG",
- "Merging JPEG codec-specific tags failed");
- return 0;
- }
-
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState));
if (tif->tif_data == NULL) {
- TIFFErrorExt(tif->tif_clientdata,
- "TIFFInitJPEG", "No space for JPEG state block");
- return 0;
+ TIFFErrorExt(tif->tif_clientdata, "TIFFInitJPEG", "No space for JPEG state block");
+ return (0);
}
- _TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
+ _TIFFmemset( tif->tif_data, 0, sizeof(JPEGState));
sp = JState(tif);
sp->tif = tif; /* back link */
/*
- * Override parent get/set field methods.
+ * Merge codec-specific tag information and override parent get/set
+ * field methods.
*/
+ _TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
- sp->printdir = tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
/* Default values for codec-specific fields */
@@ -2034,4 +1944,3 @@ TIFFInitJPEG(TIFF* tif, int scheme)
#endif /* JPEG_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
-
diff --git a/src/libtiff/tif_luv.c b/src/libtiff/tif_luv.c
index 3b43704..26ebf58 100644
--- a/src/libtiff/tif_luv.c
+++ b/src/libtiff/tif_luv.c
@@ -1,4 +1,4 @@
-/* $Id: tif_luv.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_luv.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1997 Greg Ward Larson
@@ -451,7 +451,7 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
tif->tif_rawcp = op;
tif->tif_rawcc = tif->tif_rawdatasize - occ;
- return (1);
+ return (0);
}
/*
@@ -496,7 +496,7 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
tif->tif_rawcp = op;
tif->tif_rawcc = tif->tif_rawdatasize - occ;
- return (1);
+ return (0);
}
/*
@@ -585,7 +585,7 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
tif->tif_rawcp = op;
tif->tif_rawcc = tif->tif_rawdatasize - occ;
- return (1);
+ return (0);
}
/*
@@ -598,7 +598,7 @@ LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
tsize_t rowlen = TIFFScanlineSize(tif);
assert(cc%rowlen == 0);
- while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
+ while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 0)
bp += rowlen, cc -= rowlen;
return (cc == 0);
}
@@ -613,7 +613,7 @@ LogLuvEncodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
tsize_t rowlen = TIFFTileRowSize(tif);
assert(cc%rowlen == 0);
- while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
+ while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 0)
bp += rowlen, cc -= rowlen;
return (cc == 0);
}
@@ -1200,10 +1200,7 @@ LogL16InitState(TIFF* tif)
"No support for converting user data format to LogL");
return (0);
}
- if( isTiled(tif) )
- sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength);
- else
- sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip);
+ 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",
@@ -1301,10 +1298,7 @@ LogLuvInitState(TIFF* tif)
"No support for converting user data format to LogLuv");
return (0);
}
- if( isTiled(tif) )
- sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength);
- else
- sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip);
+ 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",
@@ -1566,16 +1560,6 @@ TIFFInitSGILog(TIFF* tif, int scheme)
assert(scheme == COMPRESSION_SGILOG24 || scheme == COMPRESSION_SGILOG);
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, LogLuvFieldInfo,
- TIFFArrayCount(LogLuvFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Merging SGILog codec-specific tags failed");
- return 0;
- }
-
/*
* Allocate state block so tag methods have storage to record values.
*/
@@ -1603,9 +1587,9 @@ TIFFInitSGILog(TIFF* tif, int scheme)
tif->tif_close = LogLuvClose;
tif->tif_cleanup = LogLuvCleanup;
- /*
- * Override parent get/set field methods.
- */
+ /* override SetField so we can handle our private pseudo-tag */
+ _TIFFMergeFieldInfo(tif, LogLuvFieldInfo,
+ TIFFArrayCount(LogLuvFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = LogLuvVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
diff --git a/src/libtiff/tif_lzw.c b/src/libtiff/tif_lzw.c
index 578da97..4c9e15f 100644
--- a/src/libtiff/tif_lzw.c
+++ b/src/libtiff/tif_lzw.c
@@ -1,4 +1,4 @@
-/* $Id: tif_lzw.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_lzw.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -224,8 +224,7 @@ LZWSetupDecode(TIFF* tif)
if (sp->dec_codetab == NULL) {
sp->dec_codetab = (code_t*)_TIFFmalloc(CSIZE*sizeof (code_t));
if (sp->dec_codetab == NULL) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "No space for LZW code table");
+ TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW code table");
return (0);
}
/*
@@ -238,11 +237,6 @@ LZWSetupDecode(TIFF* tif)
sp->dec_codetab[code].length = 1;
sp->dec_codetab[code].next = NULL;
} while (code--);
- /*
- * Zero-out the unused entries
- */
- _TIFFmemset(&sp->dec_codetab[CODE_CLEAR], 0,
- (CODE_FIRST - CODE_CLEAR) * sizeof (code_t));
}
return (1);
}
@@ -257,11 +251,6 @@ LZWPreDecode(TIFF* tif, tsample_t s)
(void) s;
assert(sp != NULL);
- if( sp->dec_codetab == NULL )
- {
- tif->tif_setupdecode( tif );
- }
-
/*
* Check for old bit-reversed codes.
*/
@@ -361,7 +350,6 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
(void) s;
assert(sp != NULL);
- assert(sp->dec_codetab != NULL);
/*
* Restart interrupted output operation.
*/
@@ -420,20 +408,12 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
break;
if (code == CODE_CLEAR) {
free_entp = sp->dec_codetab + CODE_FIRST;
- _TIFFmemset(free_entp, 0,
- (CSIZE - CODE_FIRST) * sizeof (code_t));
nbits = BITS_MIN;
nbitsmask = MAXCODE(BITS_MIN);
maxcodep = sp->dec_codetab + nbitsmask-1;
NextCode(tif, sp, bp, code, GetNextCode);
if (code == CODE_EOI)
break;
- if (code == CODE_CLEAR) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "LZWDecode: Corrupted LZW table at scanline %d",
- tif->tif_row);
- return (0);
- }
*op++ = (char)code, occ--;
oldcodep = sp->dec_codetab + code;
continue;
@@ -534,7 +514,7 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
if (occ > 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "LZWDecode: Not enough data at scanline %d (short %ld bytes)",
+ "LZWDecode: Not enough data at scanline %d (short %d bytes)",
tif->tif_row, occ);
return (0);
}
@@ -624,20 +604,12 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
break;
if (code == CODE_CLEAR) {
free_entp = sp->dec_codetab + CODE_FIRST;
- _TIFFmemset(free_entp, 0,
- (CSIZE - CODE_FIRST) * sizeof (code_t));
nbits = BITS_MIN;
nbitsmask = MAXCODE(BITS_MIN);
maxcodep = sp->dec_codetab + nbitsmask;
NextCode(tif, sp, bp, code, GetNextCodeCompat);
if (code == CODE_EOI)
break;
- if (code == CODE_CLEAR) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "LZWDecode: Corrupted LZW table at scanline %d",
- tif->tif_row);
- return (0);
- }
*op++ = code, occ--;
oldcodep = sp->dec_codetab + code;
continue;
@@ -675,7 +647,6 @@ 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
* value to output (written in reverse).
@@ -710,7 +681,7 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
tp = op;
do {
*--tp = codep->value;
- } while( (codep = codep->next) != NULL && tp > op_orig);
+ } while( (codep = codep->next) != NULL);
} else
*op++ = code, occ--;
}
@@ -726,7 +697,7 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
if (occ > 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "LZWDecodeCompat: Not enough data at scanline %d (short %ld bytes)",
+ "LZWDecodeCompat: Not enough data at scanline %d (short %d bytes)",
tif->tif_row, occ);
return (0);
}
@@ -763,12 +734,6 @@ LZWPreEncode(TIFF* tif, tsample_t s)
(void) s;
assert(sp != NULL);
-
- if( sp->enc_hashtab == NULL )
- {
- tif->tif_setupencode( tif );
- }
-
sp->lzw_nbits = BITS_MIN;
sp->lzw_maxcode = MAXCODE(BITS_MIN);
sp->lzw_free_ent = CODE_FIRST;
@@ -838,9 +803,6 @@ LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
(void) s;
if (sp == NULL)
return (0);
-
- assert(sp->enc_hashtab != NULL);
-
/*
* Load local state.
*/
diff --git a/src/libtiff/tif_next.c b/src/libtiff/tif_next.c
index fc9a13d..c56dc3e 100644
--- a/src/libtiff/tif_next.c
+++ b/src/libtiff/tif_next.c
@@ -1,4 +1,4 @@
-/* $Id: tif_next.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_next.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -48,10 +48,11 @@
static int
NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
{
- unsigned char *bp, *op;
- tsize_t cc;
+ register unsigned char *bp, *op;
+ register tsize_t cc;
+ register int n;
tidata_t row;
- tsize_t scanline, n;
+ tsize_t scanline;
(void) s;
/*
@@ -65,7 +66,7 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
scanline = tif->tif_scanlinesize;
- for (row = buf; occ > 0; occ -= scanline, row += scanline) {
+ for (row = buf; (long)occ > 0; occ -= scanline, row += scanline) {
n = *bp++, cc--;
switch (n) {
case LITERALROW:
@@ -79,10 +80,10 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
cc -= scanline;
break;
case LITERALSPAN: {
- tsize_t off;
+ int off;
/*
- * The scanline has a literal span that begins at some
- * offset.
+ * The scanline has a literal span
+ * that begins at some offset.
*/
off = (bp[0] * 256) + bp[1];
n = (bp[2] * 256) + bp[3];
@@ -94,27 +95,23 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
break;
}
default: {
- uint32 npixels = 0, grey;
- uint32 imagewidth = tif->tif_dir.td_imagewidth;
+ register int npixels = 0, grey;
+ unsigned long imagewidth = tif->tif_dir.td_imagewidth;
/*
- * The scanline is composed of a sequence of constant
- * color ``runs''. We shift into ``run mode'' and
- * interpret bytes as codes of the form
- * <color><npixels> until we've filled the scanline.
+ * The scanline is composed of a sequence
+ * of constant color ``runs''. We shift
+ * into ``run mode'' and interpret bytes
+ * as codes of the form <color><npixels>
+ * until we've filled the scanline.
*/
op = row;
for (;;) {
grey = (n>>6) & 0x3;
n &= 0x3f;
- /*
- * Ensure the run does not exceed the scanline
- * bounds, potentially resulting in a security
- * issue.
- */
- while (n-- > 0 && npixels < imagewidth)
+ while (n-- > 0)
SETPIXEL(op, grey);
- if (npixels >= imagewidth)
+ if (npixels >= (int) imagewidth)
break;
if (cc == 0)
goto bad;
diff --git a/src/libtiff/tif_ojpeg.c b/src/libtiff/tif_ojpeg.c
index 0c876cd..fb6d2a2 100644
--- a/src/libtiff/tif_ojpeg.c
+++ b/src/libtiff/tif_ojpeg.c
@@ -1,2427 +1,2629 @@
-/* $Id: tif_ojpeg.c,v 1.3 2009/12/11 15:17:41 scuri 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
- images. This file was was created solely in order to read unconverted images
- still present on some users' computer systems. It will never be extended
- to write such files. Writing new-style JPEG compressed TIFFs is implemented
- in tif_jpeg.c.
-
- The code is carefully crafted to robustly read all gathered JPEG-in-TIFF
- testfiles, and anticipate as much as possible all other... But still, it may
- fail on some. If you encounter problems, please report them on the TIFF
- mailing list and/or to Joris Van Damme <info@awaresystems.be>.
-
- Please read the file called "TIFF Technical Note #2" if you need to be
- convinced this compression scheme is bad and breaks TIFF. That document
- is linked to from the LibTiff site <http://www.remotesensing.org/libtiff/>
- and from AWare Systems' TIFF section
- <http://www.awaresystems.be/imaging/tiff.html>. It is also absorbed
- in Adobe's specification supplements, marked "draft" up to this day, but
- supported by the TIFF community.
-
- This file interfaces with Release 6B of the JPEG Library written by the
- Independent JPEG Group. Previous versions of this file required a hack inside
- the LibJpeg library. This version no longer requires that. Remember to
- remove the hack if you update from the old version.
-
- Copyright (c) Joris Van Damme <info@awaresystems.be>
- Copyright (c) AWare Systems <http://www.awaresystems.be/>
-
- The licence agreement for this file is the same as the rest of the LibTiff
- library.
-
- IN NO EVENT SHALL JORIS VAN DAMME OR AWARE SYSTEMS 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.
-
- Joris Van Damme and/or AWare Systems may be available for custom
- developement. If you like what you see, and need anything similar or related,
- contact <info@awaresystems.be>.
-*/
-
-/* What is what, and what is not?
-
- This decoder starts with an input stream, that is essentially the JpegInterchangeFormat
- stream, if any, followed by the strile data, if any. This stream is read in
- OJPEGReadByte and related functions.
-
- It analyzes the start of this stream, until it encounters non-marker data, i.e.
- compressed image data. Some of the header markers it sees have no actual content,
- like the SOI marker, and APP/COM markers that really shouldn't even be there. Some
- other markers do have content, and the valuable bits and pieces of information
- in these markers are saved, checking all to verify that the stream is more or
- less within expected bounds. This happens inside the OJPEGReadHeaderInfoSecStreamXxx
- functions.
-
- Some OJPEG imagery contains no valid JPEG header markers. This situation is picked
- up on if we've seen no SOF marker when we're at the start of the compressed image
- data. In this case, the tables are read from JpegXxxTables tags, and the other
- bits and pieces of information is initialized to its most basic value. This is
- implemented in the OJPEGReadHeaderInfoSecTablesXxx functions.
-
- When this is complete, a good and valid JPEG header can be assembled, and this is
- passed through to LibJpeg. When that's done, the remainder of the input stream, i.e.
- the compressed image data, can be passed through unchanged. This is done in
- OJPEGWriteStream functions.
-
- LibTiff rightly expects to know the subsampling values before decompression. Just like
- in new-style JPEG-in-TIFF, though, or even more so, actually, the YCbCrsubsampling
- tag is notoriously unreliable. To correct these tag values with the ones inside
- the JPEG stream, the first part of the input stream is pre-scanned in
- OJPEGSubsamplingCorrect, making no note of any other data, reporting no warnings
- or errors, up to the point where either these values are read, or it's clear they
- aren't there. This means that some of the data is read twice, but we feel speed
- in correcting these values is important enough to warrant this sacrifice. Allthough
- there is currently no define or other configuration mechanism to disable this behaviour,
- the actual header scanning is build to robustly respond with error report if it
- should encounter an uncorrected mismatch of subsampling values. See
- OJPEGReadHeaderInfoSecStreamSof.
-
- The restart interval and restart markers are the most tricky part... The restart
- interval can be specified in a tag. It can also be set inside the input JPEG stream.
- It can be used inside the input JPEG stream. If reading from strile data, we've
- consistenly discovered the need to insert restart markers in between the different
- striles, as is also probably the most likely interpretation of the original TIFF 6.0
- specification. With all this setting of interval, and actual use of markers that is not
- predictable at the time of valid JPEG header assembly, the restart thing may turn
- out the Achilles heel of this implementation. Fortunately, most OJPEG writer vendors
- succeed in reading back what they write, which may be the reason why we've been able
- to discover ways that seem to work.
-
- Some special provision is made for planarconfig separate OJPEG files. These seem
- to consistently contain header info, a SOS marker, a plane, SOS marker, plane, SOS,
- and plane. This may or may not be a valid JPEG configuration, we don't know and don't
- care. We want LibTiff to be able to access the planes individually, without huge
- buffering inside LibJpeg, anyway. So we compose headers to feed to LibJpeg, in this
- case, that allow us to pass a single plane such that LibJpeg sees a valid
- single-channel JPEG stream. Locating subsequent SOS markers, and thus subsequent
- planes, is done inside OJPEGReadSecondarySos.
-
- The benefit of the scheme is... that it works, basically. We know of no other that
- does. It works without checking software tag, or otherwise going about things in an
- OJPEG flavor specific manner. Instead, it is a single scheme, that covers the cases
- with and without JpegInterchangeFormat, with and without striles, with part of
- the header in JpegInterchangeFormat and remainder in first strile, etc. It is forgiving
- and robust, may likely work with OJPEG flavors we've not seen yet, and makes most out
- of the data.
-
- Another nice side-effect is that a complete JPEG single valid stream is build if
- planarconfig is not separate (vast majority). We may one day use that to build
- converters to JPEG, and/or to new-style JPEG compression inside TIFF.
-
- A dissadvantage is the lack of random access to the individual striles. This is the
- reason for much of the complicated restart-and-position stuff inside OJPEGPreDecode.
- Applications would do well accessing all striles in order, as this will result in
- a single sequential scan of the input stream, and no restarting of LibJpeg decoding
- session.
-*/
-
+/* $Id: tif_ojpeg.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
#include "tiffiop.h"
#ifdef OJPEG_SUPPORT
-/* Configuration defines here are:
- * JPEG_ENCAP_EXTERNAL: The normal way to call libjpeg, uses longjump. In some environments,
- * like eg LibTiffDelphi, this is not possible. For this reason, the actual calls to
- * libjpeg, with longjump stuff, are encapsulated in dedicated functions. When
- * JPEG_ENCAP_EXTERNAL is defined, these encapsulating functions are declared external
- * to this unit, and can be defined elsewhere to use stuff other then longjump.
- * The default mode, without JPEG_ENCAP_EXTERNAL, implements the call encapsulators
- * here, internally, with normal longjump.
- * SETJMP, LONGJMP, JMP_BUF: On some machines/environments a longjump equivalent is
- * conviniently available, but still it may be worthwhile to use _setjmp or sigsetjmp
- * in place of plain setjmp. These macros will make it easier. It is useless
- * to fiddle with these if you define JPEG_ENCAP_EXTERNAL.
- * OJPEG_BUFFER: Define the size of the desired buffer here. Should be small enough so as to guarantee
- * instant processing, optimal streaming and optimal use of processor cache, but also big
- * enough so as to not result in significant call overhead. It should be at least a few
- * bytes to accomodate some structures (this is verified in asserts), but it would not be
- * sensible to make it this small anyway, and it should be at most 64K since it is indexed
- * with uint16. We recommend 2K.
- * EGYPTIANWALK: You could also define EGYPTIANWALK here, but it is not used anywhere and has
- * absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
- */
-
-/* #define LIBJPEG_ENCAP_EXTERNAL */
-#define SETJMP(jbuf) setjmp(jbuf)
-#define LONGJMP(jbuf,code) longjmp(jbuf,code)
-#define JMP_BUF jmp_buf
-#define OJPEG_BUFFER 2048
-/* define EGYPTIANWALK */
-
-#define JPEG_MARKER_SOF0 0xC0
-#define JPEG_MARKER_SOF1 0xC1
-#define JPEG_MARKER_SOF3 0xC3
-#define JPEG_MARKER_DHT 0xC4
-#define JPEG_MARKER_RST0 0XD0
-#define JPEG_MARKER_SOI 0xD8
-#define JPEG_MARKER_EOI 0xD9
-#define JPEG_MARKER_SOS 0xDA
-#define JPEG_MARKER_DQT 0xDB
-#define JPEG_MARKER_DRI 0xDD
-#define JPEG_MARKER_APP0 0xE0
-#define JPEG_MARKER_COM 0xFE
-
-#define FIELD_OJPEG_JPEGINTERCHANGEFORMAT (FIELD_CODEC+0)
-#define FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH (FIELD_CODEC+1)
-#define FIELD_OJPEG_JPEGQTABLES (FIELD_CODEC+2)
-#define FIELD_OJPEG_JPEGDCTABLES (FIELD_CODEC+3)
-#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"},
-};
-
-#ifndef LIBJPEG_ENCAP_EXTERNAL
+/* JPEG Compression support, as per the original TIFF 6.0 specification.
+
+ WARNING: KLUDGE ALERT! The type of JPEG encapsulation defined by the TIFF
+ Version 6.0 specification is now totally obsolete and
+ deprecated for new applications and images. This file is an unsupported hack
+ that was created solely in order to read (but NOT write!) a few old,
+ unconverted images still present on some users' computer systems. The code
+ isn't pretty or robust, and it won't read every "old format" JPEG-in-TIFF
+ file (see Samuel Leffler's draft "TIFF Technical Note No. 2" for a long and
+ incomplete list of known problems), but it seems to work well enough in the
+ few cases of practical interest to the author; so, "caveat emptor"! This
+ file should NEVER be enhanced to write new images using anything other than
+ the latest approved JPEG-in-TIFF encapsulation method, implemented by the
+ "tif_jpeg.c" file elsewhere in this library.
+
+ This file interfaces with Release 6B of the JPEG Library written by theu
+ Independent JPEG Group, which you can find on the Internet at:
+ ftp://ftp.uu.net:/graphics/jpeg/.
+
+ The "C" Preprocessor macros, "[CD]_LOSSLESS_SUPPORTED", are defined by your
+ JPEG Library Version 6B only if you have applied a (massive!) patch by Ken
+ Murchison of Oceana Matrix Ltd. <ken@oceana.com> to support lossless Huffman
+ encoding (TIFF "JPEGProc" tag value = 14). This patch can be found on the
+ Internet at: ftp://ftp.oceana.com/pub/ljpeg-6b.tar.gz.
+
+ Some old files produced by the Wang Imaging application for Microsoft Windows
+ apparently can be decoded only with a special patch to the JPEG Library,
+ which defines a subroutine named "jpeg_reset_huff_decode()" in its "jdhuff.c"
+ module (the "jdshuff.c" module, if Ken Murchison's patch has been applied).
+ Unfortunately the patch differs slightly in each case, and some TIFF Library
+ have reported problems finding the code, so both versions appear below; you
+ should carefully extract and apply only the version that applies to your JPEG
+ Library!
+
+ Contributed by Scott Marovich <marovich@hpl.hp.com> with considerable help
+ from Charles Auer <Bumble731@msn.com> to unravel the mysteries of image files
+ created by the Wang Imaging application for Microsoft Windows.
+*/
+#if 0 /* Patch for JPEG Library WITHOUT lossless Huffman coding */
+*** jdhuff.c.orig Mon Oct 20 17:51:10 1997
+--- jdhuff.c Sun Nov 11 17:33:58 2001
+***************
+*** 648,651 ****
+--- 648,683 ----
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+ }
+ }
++
++ /*
++ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
++ * TIFF encapsulations produced by Microsoft's Wang Imaging
++ * for Windows application with the public-domain TIFF Library. Based upon an
++ * examination of selected output files, this program apparently divides a JPEG
++ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
++ * encoder's/decoder's DC coefficients for each image component are reset before
++ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
++ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
++ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
++ * decoder state is not normally exposed to client applications, so this sub-
++ * routine provides the TIFF Library with a "hook" to make these corrections.
++ * It should be called after "jpeg_start_decompress()" and before
++ * "jpeg_finish_decompress()", just before decoding each "strip" using
++ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
++ *
++ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
++ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
++ * reports about this code to IJG developers. Instead, contact the author for
++ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
++ */
++ GLOBAL(void)
++ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
++ { register huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
++ register int ci = 0;
++
++ /* Discard encoded input bits, up to the next Byte boundary */
++ entropy->bitstate.bits_left &= ~7;
++ /* Re-initialize DC predictions to 0 */
++ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
++ }
+#endif /* Patch for JPEG Library WITHOUT lossless Huffman coding */
+#if 0 /* Patch for JPEG Library WITH lossless Huffman coding */
+*** jdshuff.c.orig Mon Mar 11 16:44:54 2002
+--- jdshuff.c Mon Mar 11 16:44:54 2002
+***************
+*** 357,360 ****
+--- 357,393 ----
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+ }
+ }
++
++ /*
++ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
++ * TIFF encapsulations produced by Microsoft's Wang Imaging
++ * for Windows application with the public-domain TIFF Library. Based upon an
++ * examination of selected output files, this program apparently divides a JPEG
++ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
++ * encoder's/decoder's DC coefficients for each image component are reset before
++ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
++ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
++ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
++ * decoder state is not normally exposed to client applications, so this sub-
++ * routine provides the TIFF Library with a "hook" to make these corrections.
++ * It should be called after "jpeg_start_decompress()" and before
++ * "jpeg_finish_decompress()", just before decoding each "strip" using
++ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
++ *
++ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
++ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
++ * reports about this code to IJG developers. Instead, contact the author for
++ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
++ */
++ GLOBAL(void)
++ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
++ { register shuff_entropy_ptr entropy = (shuff_entropy_ptr)
++ ((j_lossy_d_ptr)cinfo->codec)->entropy_private;
++ register int ci = 0;
++
++ /* Discard encoded input bits, up to the next Byte boundary */
++ entropy->bitstate.bits_left &= ~7;
++ /* Re-initialize DC predictions to 0 */
++ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
++ }
+#endif /* Patch for JPEG Library WITH lossless Huffman coding */
#include <setjmp.h>
+#include <stdio.h>
+#ifdef FAR
+#undef FAR /* Undefine FAR to avoid conflict with JPEG definition */
#endif
-
+#define JPEG_INTERNALS /* Include "jpegint.h" for "DSTATE_*" symbols */
+#define JPEG_CJPEG_DJPEG /* Include all Version 6B+ "jconfig.h" options */
+#undef INLINE
#include "jpeglib.h"
-#include "jerror.h"
-
-typedef struct jpeg_error_mgr jpeg_error_mgr;
-typedef struct jpeg_common_struct jpeg_common_struct;
-typedef struct jpeg_decompress_struct jpeg_decompress_struct;
-typedef struct jpeg_source_mgr jpeg_source_mgr;
+#undef JPEG_CJPEG_DJPEG
+#undef JPEG_INTERNALS
-typedef enum {
- osibsNotSetYet,
- osibsJpegInterchangeFormat,
- osibsStrile,
- osibsEof
-} OJPEGStateInBufferSource;
-
-typedef enum {
- ososSoi,
- ososQTable0,ososQTable1,ososQTable2,ososQTable3,
- ososDcTable0,ososDcTable1,ososDcTable2,ososDcTable3,
- ososAcTable0,ososAcTable1,ososAcTable2,ososAcTable3,
- ososDri,
- ososSof,
- ososSos,
- ososCompressed,
- ososRst,
- ososEoi
-} OJPEGStateOutState;
-
-typedef struct {
- TIFF* tif;
- #ifndef LIBJPEG_ENCAP_EXTERNAL
- JMP_BUF exit_jmpbuf;
- #endif
- TIFFVGetMethod vgetparent;
- TIFFVSetMethod vsetparent;
- toff_t file_size;
- uint32 image_width;
- uint32 image_length;
- uint32 strile_width;
- uint32 strile_length;
- uint32 strile_length_total;
- 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;
- uint8 jpeg_proc;
- uint8 subsamplingcorrect;
- uint8 subsamplingcorrect_done;
- uint8 subsampling_tag;
- uint8 subsampling_hor;
- uint8 subsampling_ver;
- uint8 subsampling_force_desubsampling_inside_decompression;
- 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];
- uint8* qtable[4];
- uint8* dctable[4];
- uint8* actable[4];
- uint16 restart_interval;
- uint8 restart_index;
- uint8 sof_log;
- uint8 sof_marker_id;
- uint32 sof_x;
- uint32 sof_y;
- uint8 sof_c[3];
- uint8 sof_hv[3];
- uint8 sof_tq[3];
- uint8 sos_cs[3];
- uint8 sos_tda[3];
- 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;
- } sos_end[3];
- uint8 readheader_done;
- uint8 writeheader_done;
- tsample_t write_cursample;
- tstrile_t write_curstrile;
- uint8 libjpeg_session_active;
- uint8 libjpeg_jpeg_query_style;
- jpeg_error_mgr libjpeg_jpeg_error_mgr;
- jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
- jpeg_source_mgr libjpeg_jpeg_source_mgr;
- uint8 subsampling_convert_log;
- uint32 subsampling_convert_ylinelen;
- uint32 subsampling_convert_ylines;
- uint32 subsampling_convert_clinelen;
- uint32 subsampling_convert_clines;
- uint32 subsampling_convert_ybuflen;
- uint32 subsampling_convert_cbuflen;
- uint32 subsampling_convert_ycbcrbuflen;
- uint8* subsampling_convert_ycbcrbuf;
- uint8* subsampling_convert_ybuf;
- uint8* subsampling_convert_cbbuf;
- uint8* subsampling_convert_crbuf;
- uint32 subsampling_convert_ycbcrimagelen;
- uint8** subsampling_convert_ycbcrimage;
- uint32 subsampling_convert_clinelenout;
- uint32 subsampling_convert_state;
- 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;
- uint8 in_buffer_file_pos_log;
- toff_t in_buffer_file_togo;
- uint16 in_buffer_togo;
- uint8* in_buffer_cur;
- uint8 in_buffer[OJPEG_BUFFER];
- OJPEGStateOutState out_state;
- uint8 out_buffer[OJPEG_BUFFER];
- 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 void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
-
-static int OJPEGSetupDecode(TIFF* tif);
-static int OJPEGPreDecode(TIFF* tif, tsample_t 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 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 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 OJPEGWriteHeaderInfo(TIFF* tif);
-static void OJPEGLibjpegSessionAbort(TIFF* tif);
-
-static int OJPEGReadHeaderInfoSec(TIFF* tif);
-static int OJPEGReadHeaderInfoSecStreamDri(TIFF* tif);
-static int OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif);
-static int OJPEGReadHeaderInfoSecStreamDht(TIFF* tif);
-static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id);
-static int OJPEGReadHeaderInfoSecStreamSos(TIFF* tif);
-static int OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif);
-static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif);
-static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif);
-
-static int OJPEGReadBufferFill(OJPEGState* sp);
-static int OJPEGReadByte(OJPEGState* sp, uint8* byte);
-static int OJPEGReadBytePeek(OJPEGState* sp, uint8* byte);
-static void OJPEGReadByteAdvance(OJPEGState* sp);
-static int OJPEGReadWord(OJPEGState* sp, uint16* word);
-static int OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem);
-static void OJPEGReadSkip(OJPEGState* sp, uint16 len);
-
-static int OJPEGWriteStream(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len);
-static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len);
-
-#ifdef LIBJPEG_ENCAP_EXTERNAL
-extern int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
-extern int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
-extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
-extern void jpeg_encap_unwind(TIFF* tif);
-#else
-static int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* j);
-static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
-static int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
-static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
-static void jpeg_encap_unwind(TIFF* tif);
-#endif
+/* Hack for files produced by Wang Imaging application on Microsoft Windows */
+extern void jpeg_reset_huff_decode(j_decompress_ptr);
-static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo);
-static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo);
-static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo);
-static boolean OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo);
-static void OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes);
-static boolean OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired);
-static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo);
+/* On some machines, it may be worthwhile to use "_setjmp()" or "sigsetjmp()"
+ instead of "setjmp()". These macros make it easier:
+*/
+#define SETJMP(jbuf)setjmp(jbuf)
+#define LONGJMP(jbuf,code)longjmp(jbuf,code)
+#define JMP_BUF jmp_buf
-int
-TIFFInitOJPEG(TIFF* tif, int scheme)
-{
- static const char module[]="TIFFInitOJPEG";
- OJPEGState* sp;
-
- assert(scheme==COMPRESSION_OJPEG);
-
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif,ojpeg_field_info,FIELD_OJPEG_COUNT)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Merging Old JPEG codec-specific tags failed");
- return 0;
- }
+#define TIFFTAG_WANG_PAGECONTROL 32934
- /* state block */
- sp=_TIFFmalloc(sizeof(OJPEGState));
- if (sp==NULL)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"No space for OJPEG state block");
- return(0);
- }
- _TIFFmemset(sp,0,sizeof(OJPEGState));
- sp->tif=tif;
- sp->jpeg_proc=1;
- sp->subsampling_hor=2;
- sp->subsampling_ver=2;
- TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
- /* tif codec methods */
- 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_setupencode=OJPEGSetupEncode;
- tif->tif_preencode=OJPEGPreEncode;
- tif->tif_postencode=OJPEGPostEncode;
- tif->tif_encoderow=OJPEGEncode;
- tif->tif_encodestrip=OJPEGEncode;
- tif->tif_encodetile=OJPEGEncode;
- tif->tif_cleanup=OJPEGCleanup;
- tif->tif_data=(tidata_t)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;
- 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
- in these tags. In these cases, the JpegInterchangeFormat stream is
- reliable. In any case, this decoder reads the compressed data itself,
- from the most reliable locations, and we need to notify encapsulating
- LibTiff not to read raw strips or tiles for us. */
- tif->tif_flags|=TIFF_NOREADRAW;
- return(1);
-}
+/* Bit-vector offsets for keeping track of TIFF records that we've parsed. */
-static int
-OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- switch(tag)
- {
- case TIFFTAG_JPEGIFOFFSET:
- *va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format;
- break;
- case TIFFTAG_JPEGIFBYTECOUNT:
- *va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format_length;
- break;
- case TIFFTAG_YCBCRSUBSAMPLING:
- if (sp->subsamplingcorrect_done==0)
- OJPEGSubsamplingCorrect(tif);
- *va_arg(ap,uint16*)=(uint16)sp->subsampling_hor;
- *va_arg(ap,uint16*)=(uint16)sp->subsampling_ver;
- break;
- case TIFFTAG_JPEGQTABLES:
- *va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
- *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;
- break;
- case TIFFTAG_JPEGACTABLES:
- *va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
- *va_arg(ap,void**)=(void*)sp->actable_offset;
- break;
- case TIFFTAG_JPEGPROC:
- *va_arg(ap,uint16*)=(uint16)sp->jpeg_proc;
- break;
- case TIFFTAG_JPEGRESTARTINTERVAL:
- *va_arg(ap,uint16*)=sp->restart_interval;
- break;
- default:
- return (*sp->vgetparent)(tif,tag,ap);
- }
- return (1);
-}
+#define FIELD_JPEGPROC FIELD_CODEC
+#define FIELD_JPEGIFOFFSET (FIELD_CODEC+1)
+#define FIELD_JPEGIFBYTECOUNT (FIELD_CODEC+2)
+#define FIELD_JPEGRESTARTINTERVAL (FIELD_CODEC+3)
+#define FIELD_JPEGTABLES (FIELD_CODEC+4) /* New, post-6.0 JPEG-in-TIFF tag! */
+#define FIELD_JPEGLOSSLESSPREDICTORS (FIELD_CODEC+5)
+#define FIELD_JPEGPOINTTRANSFORM (FIELD_CODEC+6)
+#define FIELD_JPEGQTABLES (FIELD_CODEC+7)
+#define FIELD_JPEGDCTABLES (FIELD_CODEC+8)
+#define FIELD_JPEGACTABLES (FIELD_CODEC+9)
+#define FIELD_WANG_PAGECONTROL (FIELD_CODEC+10)
+#define FIELD_JPEGCOLORMODE (FIELD_CODEC+11)
-static int
-OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
-{
- static const char module[]="OJPEGVSetField";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint32 ma;
- uint32* mb;
- uint32 n;
- switch(tag)
- {
- case TIFFTAG_JPEGIFOFFSET:
- sp->jpeg_interchange_format=(toff_t)va_arg(ap,uint32);
- break;
- case TIFFTAG_JPEGIFBYTECOUNT:
- sp->jpeg_interchange_format_length=(toff_t)va_arg(ap,uint32);
- break;
- case TIFFTAG_YCBCRSUBSAMPLING:
- sp->subsampling_tag=1;
- sp->subsampling_hor=(uint8)va_arg(ap,int);
- sp->subsampling_ver=(uint8)va_arg(ap,int);
- 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);
- if (ma!=0)
- {
- if (ma>3)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
- return(0);
- }
- sp->qtable_offset_count=(uint8)ma;
- mb=va_arg(ap,uint32*);
- for (n=0; n<ma; n++)
- sp->qtable_offset[n]=(toff_t)mb[n];
- }
- break;
- case TIFFTAG_JPEGDCTABLES:
- ma=va_arg(ap,uint32);
- if (ma!=0)
- {
- if (ma>3)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
- return(0);
- }
- sp->dctable_offset_count=(uint8)ma;
- mb=va_arg(ap,uint32*);
- for (n=0; n<ma; n++)
- sp->dctable_offset[n]=(toff_t)mb[n];
- }
- break;
- case TIFFTAG_JPEGACTABLES:
- ma=va_arg(ap,uint32);
- if (ma!=0)
- {
- if (ma>3)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
- return(0);
- }
- sp->actable_offset_count=(uint8)ma;
- mb=va_arg(ap,uint32*);
- for (n=0; n<ma; n++)
- sp->actable_offset[n]=(toff_t)mb[n];
- }
- break;
- case TIFFTAG_JPEGPROC:
- sp->jpeg_proc=(uint8)va_arg(ap,uint32);
- break;
- case TIFFTAG_JPEGRESTARTINTERVAL:
- sp->restart_interval=(uint16)va_arg(ap,uint32);
- break;
- default:
- return (*sp->vsetparent)(tif,tag,ap);
- }
- TIFFSetFieldBit(tif,_TIFFFieldWithTag(tif,tag)->field_bit);
- tif->tif_flags|=TIFF_DIRTYDIRECT;
- return(1);
-}
+typedef struct jpeg_destination_mgr jpeg_destination_mgr;
+typedef struct jpeg_source_mgr jpeg_source_mgr;
+typedef struct jpeg_error_mgr jpeg_error_mgr;
+/* State variable for each open TIFF file that uses "libjpeg" for JPEG
+ decompression. (Note: This file should NEVER perform JPEG compression
+ except in the manner implemented by the "tif_jpeg.c" file, elsewhere in this
+ library; see comments above.) JPEG Library internal state is recorded in a
+ "jpeg_{de}compress_struct", while a "jpeg_common_struct" records a few items
+ common to both compression and expansion. The "cinfo" field containing JPEG
+ Library state MUST be the 1st member of our own state variable, so that we
+ can safely "cast" pointers back and forth.
+*/
+typedef struct /* This module's private, per-image state variable */
+ {
+ union /* JPEG Library state variable; this MUST be our 1st field! */
+ {
+ struct jpeg_compress_struct c;
+ struct jpeg_decompress_struct d;
+ struct jpeg_common_struct comm;
+ } cinfo;
+ jpeg_error_mgr err; /* JPEG Library error manager */
+ JMP_BUF exit_jmpbuf; /* ...for catching JPEG Library failures */
+# ifdef never
+
+ /* (The following two fields could be a "union", but they're small enough that
+ it's not worth the effort.)
+ */
+ jpeg_destination_mgr dest; /* Destination for compressed data */
+# endif
+ jpeg_source_mgr src; /* Source of expanded data */
+ JSAMPARRAY ds_buffer[MAX_COMPONENTS]; /* ->Temporary downsampling buffers */
+ TIFF *tif; /* Reverse pointer, needed by some code */
+ TIFFVGetMethod vgetparent; /* "Super class" methods... */
+ TIFFVSetMethod vsetparent;
+ TIFFStripMethod defsparent;
+ TIFFTileMethod deftparent;
+ void *jpegtables; /* ->"New" JPEG tables, if we synthesized any */
+ uint32 is_WANG, /* <=> Wang Imaging for Microsoft Windows output file? */
+ jpegtables_length; /* Length of "new" JPEG tables, if they exist */
+ tsize_t bytesperline; /* No. of decompressed Bytes per scan line */
+ int jpegquality, /* Compression quality level */
+ jpegtablesmode, /* What to put in JPEGTables */
+ samplesperclump,
+ scancount; /* No. of scan lines accumulated */
+ J_COLOR_SPACE photometric; /* IJG JPEG Library's photometry code */
+ unsigned char h_sampling, /* Luminance sampling factors */
+ v_sampling,
+ jpegcolormode; /* Who performs RGB <-> YCbCr conversion? */
+ /* JPEGCOLORMODE_RAW <=> TIFF Library or its client */
+ /* JPEGCOLORMODE_RGB <=> JPEG Library */
+ /* These fields are added to support TIFFGetField */
+ uint16 jpegproc;
+ uint32 jpegifoffset;
+ uint32 jpegifbytecount;
+ uint32 jpegrestartinterval;
+ void* jpeglosslesspredictors;
+ uint16 jpeglosslesspredictors_length;
+ void* jpegpointtransform;
+ uint32 jpegpointtransform_length;
+ void* jpegqtables;
+ uint32 jpegqtables_length;
+ void* jpegdctables;
+ uint32 jpegdctables_length;
+ void* jpegactables;
+ uint32 jpegactables_length;
+
+ } OJPEGState;
+#define OJState(tif)((OJPEGState*)(tif)->tif_data)
+
+static const TIFFFieldInfo ojpegFieldInfo[]=/* JPEG-specific TIFF-record tags */
+ {
+
+ /* This is the current JPEG-in-TIFF metadata-encapsulation tag, and its
+ treatment in this file is idiosyncratic. It should never appear in a
+ "source" image conforming to the TIFF Version 6.0 specification, so we
+ arrange to report an error if it appears. But in order to support possible
+ future conversion of "old" JPEG-in-TIFF encapsulations to "new" ones, we
+ might wish to synthesize an equivalent value to be returned by the TIFF
+ Library's "getfield" method. So, this table tells the TIFF Library to pass
+ these records to us in order to filter them below.
+ */
+ {
+ TIFFTAG_JPEGTABLES ,TIFF_VARIABLE2,TIFF_VARIABLE2,
+ TIFF_UNDEFINED,FIELD_JPEGTABLES ,FALSE,TRUE ,"JPEGTables"
+ },
+
+ /* These tags are defined by the TIFF Version 6.0 specification and are now
+ obsolete. This module reads them from an old "source" image, but it never
+ writes them to a new "destination" image.
+ */
+ {
+ TIFFTAG_JPEGPROC ,1 ,1 ,
+ TIFF_SHORT ,FIELD_JPEGPROC ,FALSE,FALSE,"JPEGProc"
+ },
+ {
+ TIFFTAG_JPEGIFOFFSET ,1 ,1 ,
+ TIFF_LONG ,FIELD_JPEGIFOFFSET ,FALSE,FALSE,"JPEGInterchangeFormat"
+ },
+ {
+ TIFFTAG_JPEGIFBYTECOUNT ,1 ,1 ,
+ TIFF_LONG ,FIELD_JPEGIFBYTECOUNT ,FALSE,FALSE,"JPEGInterchangeFormatLength"
+ },
+ {
+ TIFFTAG_JPEGRESTARTINTERVAL ,1 ,1 ,
+ TIFF_SHORT ,FIELD_JPEGRESTARTINTERVAL ,FALSE,FALSE,"JPEGRestartInterval"
+ },
+ {
+ TIFFTAG_JPEGLOSSLESSPREDICTORS,TIFF_VARIABLE,TIFF_VARIABLE,
+ TIFF_SHORT ,FIELD_JPEGLOSSLESSPREDICTORS,FALSE,TRUE ,"JPEGLosslessPredictors"
+ },
+ {
+ TIFFTAG_JPEGPOINTTRANSFORM ,TIFF_VARIABLE,TIFF_VARIABLE,
+ TIFF_SHORT ,FIELD_JPEGPOINTTRANSFORM ,FALSE,TRUE ,"JPEGPointTransforms"
+ },
+ {
+ TIFFTAG_JPEGQTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
+ TIFF_LONG ,FIELD_JPEGQTABLES ,FALSE,TRUE ,"JPEGQTables"
+ },
+ {
+ TIFFTAG_JPEGDCTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
+ TIFF_LONG ,FIELD_JPEGDCTABLES ,FALSE,TRUE ,"JPEGDCTables"
+ },
+ {
+ TIFFTAG_JPEGACTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
+ TIFF_LONG ,FIELD_JPEGACTABLES ,FALSE,TRUE ,"JPEGACTables"
+ },
+ {
+ TIFFTAG_WANG_PAGECONTROL ,TIFF_VARIABLE,1 ,
+ TIFF_LONG ,FIELD_WANG_PAGECONTROL ,FALSE,FALSE,"WANG PageControl"
+ },
+
+ /* This is a pseudo tag intended for internal use only by the TIFF Library and
+ its clients, which should never appear in an input/output image file. It
+ specifies whether the TIFF Library (or its client) should do YCbCr <-> RGB
+ color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we should ask
+ the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
+ */
+ {
+ TIFFTAG_JPEGCOLORMODE ,0 ,0 ,
+ TIFF_ANY ,FIELD_PSEUDO ,FALSE,FALSE,"JPEGColorMode"
+ }
+ };
+static const char JPEGLib_name[]={"JPEG Library"},
+ bad_bps[]={"%u BitsPerSample not allowed for JPEG"},
+ bad_photometry[]={"PhotometricInterpretation %u not allowed for JPEG"},
+ bad_subsampling[]={"invalid YCbCr subsampling factor(s)"},
+# ifdef never
+ no_write_frac[]={"fractional scan line discarded"},
+# endif
+ no_read_frac[]={"fractional scan line not read"},
+ no_jtable_space[]={"No space for JPEGTables"};
+
+/* The following diagnostic subroutines interface with and replace default
+ subroutines in the JPEG Library. Our basic strategy is to use "setjmp()"/
+ "longjmp()" in order to return control to the TIFF Library when the JPEG
+ library detects an error, and to use TIFF Library subroutines for displaying
+ diagnostic messages to a client application.
+*/
static void
-OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
+TIFFojpeg_error_exit(register j_common_ptr cinfo)
{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- (void)flags;
- assert(sp!=NULL);
- if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
- fprintf(fd," JpegInterchangeFormat: %lu\n",(unsigned long)sp->jpeg_interchange_format);
- if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
- fprintf(fd," JpegInterchangeFormatLength: %lu\n",(unsigned long)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,"\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,"\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,"\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);
-}
-
-static int
-OJPEGSetupDecode(TIFF* tif)
-{
- static const char module[]="OJPEGSetupDecode";
- TIFFWarningExt(tif->tif_clientdata,module,"Depreciated and troublesome old-style JPEG compression mode, please convert to new-style JPEG compression and notify vendor of writing software");
- return(1);
-}
-
-static int
-OJPEGPreDecode(TIFF* tif, tsample_t s)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- tstrile_t m;
- if (sp->subsamplingcorrect_done==0)
- OJPEGSubsamplingCorrect(tif);
- if (sp->readheader_done==0)
- {
- if (OJPEGReadHeaderInfo(tif)==0)
- return(0);
- }
- if (sp->sos_end[s].log==0)
- {
- if (OJPEGReadSecondarySos(tif,s)==0)
- return(0);
- }
- if isTiled(tif)
- m=(tstrile_t)tif->tif_curtile;
- else
- m=(tstrile_t)tif->tif_curstrip;
- if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
- {
- if (sp->libjpeg_session_active!=0)
- OJPEGLibjpegSessionAbort(tif);
- sp->writeheader_done=0;
- }
- if (sp->writeheader_done==0)
- {
- sp->plane_sample_offset=s;
- sp->write_cursample=s;
- sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
- if ((sp->in_buffer_file_pos_log==0) ||
- (sp->in_buffer_file_pos-sp->in_buffer_togo!=sp->sos_end[s].in_buffer_file_pos))
- {
- sp->in_buffer_source=sp->sos_end[s].in_buffer_source;
- sp->in_buffer_next_strile=sp->sos_end[s].in_buffer_next_strile;
- sp->in_buffer_file_pos=sp->sos_end[s].in_buffer_file_pos;
- sp->in_buffer_file_pos_log=0;
- sp->in_buffer_file_togo=sp->sos_end[s].in_buffer_file_togo;
- sp->in_buffer_togo=0;
- sp->in_buffer_cur=0;
- }
- if (OJPEGWriteHeaderInfo(tif)==0)
- return(0);
- }
- while (sp->write_curstrile<m)
- {
- if (sp->libjpeg_jpeg_query_style==0)
- {
- if (OJPEGPreDecodeSkipRaw(tif)==0)
- return(0);
- }
- else
- {
- if (OJPEGPreDecodeSkipScanlines(tif)==0)
- return(0);
- }
- sp->write_curstrile++;
- }
- return(1);
-}
-
-static int
-OJPEGPreDecodeSkipRaw(TIFF* tif)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint32 m;
- m=sp->lines_per_strile;
- if (sp->subsampling_convert_state!=0)
- {
- if (sp->subsampling_convert_clines-sp->subsampling_convert_state>=m)
- {
- sp->subsampling_convert_state+=m;
- if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
- sp->subsampling_convert_state=0;
- return(1);
- }
- m-=sp->subsampling_convert_clines-sp->subsampling_convert_state;
- sp->subsampling_convert_state=0;
- }
- while (m>=sp->subsampling_convert_clines)
- {
- if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
- return(0);
- m-=sp->subsampling_convert_clines;
- }
- if (m>0)
- {
- if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
- return(0);
- sp->subsampling_convert_state=m;
- }
- return(1);
-}
-
-static int
-OJPEGPreDecodeSkipScanlines(TIFF* tif)
-{
- static const char module[]="OJPEGPreDecodeSkipScanlines";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint32 m;
- if (sp->skip_buffer==NULL)
- {
- sp->skip_buffer=_TIFFmalloc(sp->bytes_per_line);
- if (sp->skip_buffer==NULL)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- }
- for (m=0; m<sp->lines_per_strile; m++)
- {
- if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&sp->skip_buffer,1)==0)
- return(0);
- }
- return(1);
-}
-
-static int
-OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- (void)s;
- if (sp->libjpeg_jpeg_query_style==0)
- {
- if (OJPEGDecodeRaw(tif,buf,cc)==0)
- return(0);
- }
- else
- {
- if (OJPEGDecodeScanlines(tif,buf,cc)==0)
- return(0);
- }
- return(1);
-}
-
-static int
-OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc)
-{
- static const char module[]="OJPEGDecodeRaw";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8* m;
- uint32 n;
- uint8* oy;
- uint8* ocb;
- uint8* ocr;
- uint8* p;
- uint32 q;
- uint8* r;
- uint8 sx,sy;
- if (cc%sp->bytes_per_line!=0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
- return(0);
- }
- assert(cc>0);
- m=buf;
- n=cc;
- do
- {
- if (sp->subsampling_convert_state==0)
- {
- if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
- return(0);
- }
- oy=sp->subsampling_convert_ybuf+sp->subsampling_convert_state*sp->subsampling_ver*sp->subsampling_convert_ylinelen;
- ocb=sp->subsampling_convert_cbbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
- ocr=sp->subsampling_convert_crbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
- p=m;
- for (q=0; q<sp->subsampling_convert_clinelenout; q++)
- {
- r=oy;
- for (sy=0; sy<sp->subsampling_ver; sy++)
- {
- for (sx=0; sx<sp->subsampling_hor; sx++)
- *p++=*r++;
- r+=sp->subsampling_convert_ylinelen-sp->subsampling_hor;
- }
- oy+=sp->subsampling_hor;
- *p++=*ocb++;
- *p++=*ocr++;
- }
- sp->subsampling_convert_state++;
- if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
- sp->subsampling_convert_state=0;
- m+=sp->bytes_per_line;
- n-=sp->bytes_per_line;
- } while(n>0);
- return(1);
-}
-
-static int
-OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc)
-{
- static const char module[]="OJPEGDecodeScanlines";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8* m;
- uint32 n;
- if (cc%sp->bytes_per_line!=0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
- return(0);
- }
- assert(cc>0);
- m=buf;
- n=cc;
- do
- {
- if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&m,1)==0)
- return(0);
- m+=sp->bytes_per_line;
- n-=sp->bytes_per_line;
- } while(n>0);
- return(1);
+ char buffer[JMSG_LENGTH_MAX];
+ int code = cinfo->err->msg_code;
+
+ if (((OJPEGState *)cinfo)->is_WANG) {
+ if (code == JERR_SOF_DUPLICATE || code == JERR_SOI_DUPLICATE)
+ return; /* ignore it */
+ }
+
+ (*cinfo->err->format_message)(cinfo,buffer);
+ TIFFError(JPEGLib_name,buffer); /* Display error message */
+ jpeg_abort(cinfo); /* Clean up JPEG Library state */
+ LONGJMP(((OJPEGState *)cinfo)->exit_jmpbuf,1); /* Return to TIFF client */
}
static void
-OJPEGPostDecode(TIFF* tif, tidata_t buf, tsize_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)
- {
- assert(sp->libjpeg_session_active!=0);
- OJPEGLibjpegSessionAbort(tif);
- sp->writeheader_done=0;
- }
-}
-
-static int
-OJPEGSetupEncode(TIFF* tif)
-{
- static const char module[]="OJPEGSetupEncode";
- TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
- return(0);
-}
+TIFFojpeg_output_message(register j_common_ptr cinfo)
+ { char buffer[JMSG_LENGTH_MAX];
-static int
-OJPEGPreEncode(TIFF* tif, tsample_t s)
-{
- static const char module[]="OJPEGPreEncode";
- (void)s;
- TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
- return(0);
-}
+ /* This subroutine is invoked only for warning messages, since the JPEG
+ Library's "error_exit" method does its own thing and "trace_level" is never
+ set > 0.
+ */
+ (*cinfo->err->format_message)(cinfo,buffer);
+ TIFFWarning(JPEGLib_name,buffer);
+ }
-static int
-OJPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
-{
- static const char module[]="OJPEGEncode";
- (void)buf;
- (void)cc;
- (void)s;
- TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
- return(0);
-}
+/* The following subroutines, which also interface with the JPEG Library, exist
+ mainly in limit the side effects of "setjmp()" and convert JPEG normal/error
+ conditions into TIFF Library return codes.
+*/
+#define CALLJPEG(sp,fail,op)(SETJMP((sp)->exit_jmpbuf)?(fail):(op))
+#define CALLVJPEG(sp,op)CALLJPEG(sp,0,((op),1))
+#ifdef never
static int
-OJPEGPostEncode(TIFF* tif)
-{
- static const char module[]="OJPEGPostEncode";
- TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
- return(0);
-}
-
-static void
-OJPEGCleanup(TIFF* tif)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- if (sp!=0)
- {
- tif->tif_tagmethods.vgetfield=sp->vgetparent;
- tif->tif_tagmethods.vsetfield=sp->vsetparent;
- if (sp->qtable[0]!=0)
- _TIFFfree(sp->qtable[0]);
- if (sp->qtable[1]!=0)
- _TIFFfree(sp->qtable[1]);
- if (sp->qtable[2]!=0)
- _TIFFfree(sp->qtable[2]);
- if (sp->qtable[3]!=0)
- _TIFFfree(sp->qtable[3]);
- if (sp->dctable[0]!=0)
- _TIFFfree(sp->dctable[0]);
- if (sp->dctable[1]!=0)
- _TIFFfree(sp->dctable[1]);
- if (sp->dctable[2]!=0)
- _TIFFfree(sp->dctable[2]);
- if (sp->dctable[3]!=0)
- _TIFFfree(sp->dctable[3]);
- if (sp->actable[0]!=0)
- _TIFFfree(sp->actable[0]);
- if (sp->actable[1]!=0)
- _TIFFfree(sp->actable[1]);
- if (sp->actable[2]!=0)
- _TIFFfree(sp->actable[2]);
- if (sp->actable[3]!=0)
- _TIFFfree(sp->actable[3]);
- if (sp->libjpeg_session_active!=0)
- OJPEGLibjpegSessionAbort(tif);
- if (sp->subsampling_convert_ycbcrbuf!=0)
- _TIFFfree(sp->subsampling_convert_ycbcrbuf);
- if (sp->subsampling_convert_ycbcrimage!=0)
- _TIFFfree(sp->subsampling_convert_ycbcrimage);
- if (sp->skip_buffer!=0)
- _TIFFfree(sp->skip_buffer);
- _TIFFfree(sp);
- tif->tif_data=NULL;
- _TIFFSetDefaultCompressionState(tif);
- }
-}
-
+TIFFojpeg_create_compress(register OJPEGState *sp)
+ {
+ sp->cinfo.c.err = jpeg_std_error(&sp->err); /* Initialize error handling */
+ sp->err.error_exit = TIFFojpeg_error_exit;
+ sp->err.output_message = TIFFojpeg_output_message;
+ return CALLVJPEG(sp,jpeg_create_compress(&sp->cinfo.c));
+ }
+
+/* The following subroutines comprise a JPEG Library "destination" data manager
+ by directing compressed data from the JPEG Library to a TIFF Library output
+ buffer.
+*/
static void
-OJPEGSubsamplingCorrect(TIFF* tif)
-{
- static const char module[]="OJPEGSubsamplingCorrect";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 mh;
- uint8 mv;
- 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)))
- {
- if (sp->subsampling_tag!=0)
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag not appropriate for this Photometric and/or SamplesPerPixel");
- sp->subsampling_hor=1;
- sp->subsampling_ver=1;
- sp->subsampling_force_desubsampling_inside_decompression=0;
- }
- else
- {
- sp->subsamplingcorrect_done=1;
- mh=sp->subsampling_hor;
- mv=sp->subsampling_ver;
- sp->subsamplingcorrect=1;
- OJPEGReadHeaderInfoSec(tif);
- if (sp->subsampling_force_desubsampling_inside_decompression!=0)
- {
- sp->subsampling_hor=1;
- sp->subsampling_ver=1;
- }
- sp->subsamplingcorrect=0;
- if (((sp->subsampling_hor!=mh) || (sp->subsampling_ver!=mv)) && (sp->subsampling_force_desubsampling_inside_decompression==0))
- {
- if (sp->subsampling_tag==0)
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data [%d,%d] does not match default values [2,2]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver);
- else
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data [%d,%d] does not match subsampling tag values [%d,%d]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver,mh,mv);
- }
- if (sp->subsampling_force_desubsampling_inside_decompression!=0)
- {
- if (sp->subsampling_tag==0)
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data does not match default values [2,2] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression");
- else
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data does not match subsampling tag values [%d,%d] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression",mh,mv);
- }
- if (sp->subsampling_force_desubsampling_inside_decompression==0)
- {
- if (sp->subsampling_hor<sp->subsampling_ver)
- TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%d,%d] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
- }
- }
- sp->subsamplingcorrect_done=1;
-}
-
-static int
-OJPEGReadHeaderInfo(TIFF* tif)
-{
- static const char module[]="OJPEGReadHeaderInfo";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(sp->readheader_done==0);
- sp->image_width=tif->tif_dir.td_imagewidth;
- sp->image_length=tif->tif_dir.td_imagelength;
- if isTiled(tif)
- {
- sp->strile_width=tif->tif_dir.td_tilewidth;
- sp->strile_length=tif->tif_dir.td_tilelength;
- sp->strile_length_total=((sp->image_length+sp->strile_length-1)/sp->strile_length)*sp->strile_length;
- }
- else
- {
- sp->strile_width=sp->image_width;
- 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)
- {
- sp->plane_sample_offset=0;
- sp->samples_per_pixel_per_plane=sp->samples_per_pixel;
- sp->subsampling_hor=1;
- sp->subsampling_ver=1;
- }
- else
- {
- if (sp->samples_per_pixel!=3)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
- return(0);
- }
- sp->plane_sample_offset=0;
- if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
- sp->samples_per_pixel_per_plane=3;
- else
- sp->samples_per_pixel_per_plane=1;
- }
- if (sp->strile_length<sp->image_length)
- {
- if (sp->strile_length%(sp->subsampling_ver*8)!=0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Incompatible vertical subsampling and image strip/tile length");
- return(0);
- }
- sp->restart_interval=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8))*(sp->strile_length/(sp->subsampling_ver*8));
- }
- if (OJPEGReadHeaderInfoSec(tif)==0)
- return(0);
- sp->sos_end[0].log=1;
- 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->readheader_done=1;
- return(1);
-}
+std_init_destination(register j_compress_ptr cinfo){} /* "Dummy" stub */
-static int
-OJPEGReadSecondarySos(TIFF* tif, tsample_t s)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- assert(s>0);
- assert(s<3);
- assert(sp->sos_end[0].log!=0);
- assert(sp->sos_end[s].log==0);
- sp->plane_sample_offset=s-1;
- while(sp->sos_end[sp->plane_sample_offset].log==0)
- 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_log=0;
- sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo;
- sp->in_buffer_togo=0;
- sp->in_buffer_cur=0;
- while(sp->plane_sample_offset<s)
- {
- do
- {
- if (OJPEGReadByte(sp,&m)==0)
- return(0);
- if (m==255)
- {
- do
- {
- if (OJPEGReadByte(sp,&m)==0)
- return(0);
- if (m!=255)
- break;
- } while(1);
- if (m==JPEG_MARKER_SOS)
- break;
- }
- } while(1);
- sp->plane_sample_offset++;
- if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
- return(0);
- sp->sos_end[sp->plane_sample_offset].log=1;
- sp->sos_end[sp->plane_sample_offset].in_buffer_source=sp->in_buffer_source;
- sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile=sp->in_buffer_next_strile;
- sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
- sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
- }
- return(1);
-}
-
-static int
-OJPEGWriteHeaderInfo(TIFF* tif)
-{
- static const char module[]="OJPEGWriteHeaderInfo";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8** m;
- uint32 n;
- assert(sp->libjpeg_session_active==0);
- sp->out_state=ososSoi;
- sp->restart_index=0;
- jpeg_std_error(&(sp->libjpeg_jpeg_error_mgr));
- sp->libjpeg_jpeg_error_mgr.output_message=OJPEGLibjpegJpegErrorMgrOutputMessage;
- sp->libjpeg_jpeg_error_mgr.error_exit=OJPEGLibjpegJpegErrorMgrErrorExit;
- sp->libjpeg_jpeg_decompress_struct.err=&(sp->libjpeg_jpeg_error_mgr);
- sp->libjpeg_jpeg_decompress_struct.client_data=(void*)tif;
- if (jpeg_create_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
- return(0);
- sp->libjpeg_session_active=1;
- sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=0;
- sp->libjpeg_jpeg_source_mgr.init_source=OJPEGLibjpegJpegSourceMgrInitSource;
- sp->libjpeg_jpeg_source_mgr.fill_input_buffer=OJPEGLibjpegJpegSourceMgrFillInputBuffer;
- sp->libjpeg_jpeg_source_mgr.skip_input_data=OJPEGLibjpegJpegSourceMgrSkipInputData;
- sp->libjpeg_jpeg_source_mgr.resync_to_restart=OJPEGLibjpegJpegSourceMgrResyncToRestart;
- sp->libjpeg_jpeg_source_mgr.term_source=OJPEGLibjpegJpegSourceMgrTermSource;
- sp->libjpeg_jpeg_decompress_struct.src=&(sp->libjpeg_jpeg_source_mgr);
- if (jpeg_read_header_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),1)==0)
- return(0);
- if ((sp->subsampling_force_desubsampling_inside_decompression==0) && (sp->samples_per_pixel_per_plane>1))
- {
- sp->libjpeg_jpeg_decompress_struct.raw_data_out=1;
-#if JPEG_LIB_VERSION >= 70
- sp->libjpeg_jpeg_decompress_struct.do_fancy_upsampling=FALSE;
-#endif
- sp->libjpeg_jpeg_query_style=0;
- if (sp->subsampling_convert_log==0)
- {
- assert(sp->subsampling_convert_ycbcrbuf==0);
- assert(sp->subsampling_convert_ycbcrimage==0);
- sp->subsampling_convert_ylinelen=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8)*sp->subsampling_hor*8);
- sp->subsampling_convert_ylines=sp->subsampling_ver*8;
- sp->subsampling_convert_clinelen=sp->subsampling_convert_ylinelen/sp->subsampling_hor;
- sp->subsampling_convert_clines=8;
- sp->subsampling_convert_ybuflen=sp->subsampling_convert_ylinelen*sp->subsampling_convert_ylines;
- sp->subsampling_convert_cbuflen=sp->subsampling_convert_clinelen*sp->subsampling_convert_clines;
- sp->subsampling_convert_ycbcrbuflen=sp->subsampling_convert_ybuflen+2*sp->subsampling_convert_cbuflen;
- sp->subsampling_convert_ycbcrbuf=_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen);
- if (sp->subsampling_convert_ycbcrbuf==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- sp->subsampling_convert_ybuf=sp->subsampling_convert_ycbcrbuf;
- sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
- sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
- sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
- sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8*));
- if (sp->subsampling_convert_ycbcrimage==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- m=sp->subsampling_convert_ycbcrimage;
- *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
- *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
- *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
- for (n=0; n<sp->subsampling_convert_ylines; n++)
- *m++=sp->subsampling_convert_ybuf+n*sp->subsampling_convert_ylinelen;
- for (n=0; n<sp->subsampling_convert_clines; n++)
- *m++=sp->subsampling_convert_cbbuf+n*sp->subsampling_convert_clinelen;
- for (n=0; n<sp->subsampling_convert_clines; n++)
- *m++=sp->subsampling_convert_crbuf+n*sp->subsampling_convert_clinelen;
- sp->subsampling_convert_clinelenout=((sp->strile_width+sp->subsampling_hor-1)/sp->subsampling_hor);
- sp->subsampling_convert_state=0;
- sp->bytes_per_line=sp->subsampling_convert_clinelenout*(sp->subsampling_ver*sp->subsampling_hor+2);
- sp->lines_per_strile=((sp->strile_length+sp->subsampling_ver-1)/sp->subsampling_ver);
- sp->subsampling_convert_log=1;
- }
- }
- else
- {
- sp->libjpeg_jpeg_decompress_struct.jpeg_color_space=JCS_UNKNOWN;
- sp->libjpeg_jpeg_decompress_struct.out_color_space=JCS_UNKNOWN;
- sp->libjpeg_jpeg_query_style=1;
- sp->bytes_per_line=sp->samples_per_pixel_per_plane*sp->strile_width;
- sp->lines_per_strile=sp->strile_length;
- }
- if (jpeg_start_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
- return(0);
- sp->writeheader_done=1;
- return(1);
-}
+static boolean
+std_empty_output_buffer(register j_compress_ptr cinfo)
+ {
+# define sp ((OJPEGState *)cinfo)
+ register TIFF *tif = sp->tif;
+
+ tif->tif_rawcc = tif->tif_rawdatasize; /* Entire buffer has been filled */
+ TIFFFlushData1(tif);
+ sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata;
+ sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize;
+ return TRUE;
+# undef sp
+ }
static void
-OJPEGLibjpegSessionAbort(TIFF* tif)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(sp->libjpeg_session_active!=0);
- jpeg_destroy((jpeg_common_struct*)(&(sp->libjpeg_jpeg_decompress_struct)));
- sp->libjpeg_session_active=0;
-}
-
-static int
-OJPEGReadHeaderInfoSec(TIFF* tif)
-{
- static const char module[]="OJPEGReadHeaderInfoSec";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- uint16 n;
- uint8 o;
- if (sp->file_size==0)
- sp->file_size=TIFFGetFileSize(tif);
- if (sp->jpeg_interchange_format!=0)
- {
- if (sp->jpeg_interchange_format>=sp->file_size)
- {
- sp->jpeg_interchange_format=0;
- sp->jpeg_interchange_format_length=0;
- }
- else
- {
- if ((sp->jpeg_interchange_format_length==0) || (sp->jpeg_interchange_format+sp->jpeg_interchange_format_length>sp->file_size))
- sp->jpeg_interchange_format_length=sp->file_size-sp->jpeg_interchange_format;
- }
- }
- sp->in_buffer_source=osibsNotSetYet;
- sp->in_buffer_next_strile=0;
- sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
- sp->in_buffer_file_togo=0;
- sp->in_buffer_togo=0;
- do
- {
- if (OJPEGReadBytePeek(sp,&m)==0)
- return(0);
- if (m!=255)
- break;
- OJPEGReadByteAdvance(sp);
- do
- {
- if (OJPEGReadByte(sp,&m)==0)
- return(0);
- } while(m==255);
- switch(m)
- {
- case JPEG_MARKER_SOI:
- /* this type of marker has no data, and should be skipped */
- break;
- case JPEG_MARKER_COM:
- case JPEG_MARKER_APP0:
- case JPEG_MARKER_APP0+1:
- case JPEG_MARKER_APP0+2:
- case JPEG_MARKER_APP0+3:
- case JPEG_MARKER_APP0+4:
- case JPEG_MARKER_APP0+5:
- case JPEG_MARKER_APP0+6:
- case JPEG_MARKER_APP0+7:
- case JPEG_MARKER_APP0+8:
- case JPEG_MARKER_APP0+9:
- case JPEG_MARKER_APP0+10:
- case JPEG_MARKER_APP0+11:
- case JPEG_MARKER_APP0+12:
- case JPEG_MARKER_APP0+13:
- case JPEG_MARKER_APP0+14:
- case JPEG_MARKER_APP0+15:
- /* this type of marker has data, but it has no use to us (and no place here) and should be skipped */
- if (OJPEGReadWord(sp,&n)==0)
- return(0);
- if (n<2)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
- return(0);
- }
- if (n>2)
- OJPEGReadSkip(sp,n-2);
- break;
- case JPEG_MARKER_DRI:
- if (OJPEGReadHeaderInfoSecStreamDri(tif)==0)
- return(0);
- break;
- case JPEG_MARKER_DQT:
- if (OJPEGReadHeaderInfoSecStreamDqt(tif)==0)
- return(0);
- break;
- case JPEG_MARKER_DHT:
- if (OJPEGReadHeaderInfoSecStreamDht(tif)==0)
- return(0);
- break;
- case JPEG_MARKER_SOF0:
- case JPEG_MARKER_SOF1:
- case JPEG_MARKER_SOF3:
- if (OJPEGReadHeaderInfoSecStreamSof(tif,m)==0)
- return(0);
- if (sp->subsamplingcorrect!=0)
- return(1);
- break;
- case JPEG_MARKER_SOS:
- if (sp->subsamplingcorrect!=0)
- return(1);
- assert(sp->plane_sample_offset==0);
- if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
- return(0);
- break;
- default:
- TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %d in JPEG data",m);
- return(0);
- }
- } while(m!=JPEG_MARKER_SOS);
- if (sp->subsamplingcorrect)
- return(1);
- if (sp->sof_log==0)
- {
- if (OJPEGReadHeaderInfoSecTablesQTable(tif)==0)
- return(0);
- sp->sof_marker_id=JPEG_MARKER_SOF0;
- for (o=0; o<sp->samples_per_pixel; o++)
- sp->sof_c[o]=o;
- sp->sof_hv[0]=((sp->subsampling_hor<<4)|sp->subsampling_ver);
- for (o=1; o<sp->samples_per_pixel; o++)
- sp->sof_hv[o]=17;
- sp->sof_x=sp->strile_width;
- sp->sof_y=sp->strile_length_total;
- sp->sof_log=1;
- if (OJPEGReadHeaderInfoSecTablesDcTable(tif)==0)
- return(0);
- if (OJPEGReadHeaderInfoSecTablesAcTable(tif)==0)
- return(0);
- for (o=1; o<sp->samples_per_pixel; o++)
- sp->sos_cs[o]=o;
- }
- return(1);
-}
+std_term_destination(register j_compress_ptr cinfo)
+ {
+# define sp ((OJPEGState *)cinfo)
+ register TIFF *tif = sp->tif;
-static int
-OJPEGReadHeaderInfoSecStreamDri(TIFF* tif)
-{
- /* this could easilly cause trouble in some cases... but no such cases have occured sofar */
- static const char module[]="OJPEGReadHeaderInfoSecStreamDri";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint16 m;
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- if (m!=4)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DRI marker in JPEG data");
- return(0);
- }
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- sp->restart_interval=m;
- return(1);
-}
+ /* NB: The TIFF Library does the final buffer flush. */
+ tif->tif_rawcp = (tidata_t)sp->dest.next_output_byte;
+ tif->tif_rawcc = tif->tif_rawdatasize - (tsize_t)sp->dest.free_in_buffer;
+# undef sp
+ }
-static int
-OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
-{
- /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
- static const char module[]="OJPEGReadHeaderInfoSecStreamDqt";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint16 m;
- uint32 na;
- uint8* nb;
- uint8 o;
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- if (m<=2)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
- return(0);
- }
- if (sp->subsamplingcorrect!=0)
- OJPEGReadSkip(sp,m-2);
- else
- {
- m-=2;
- do
- {
- if (m<65)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
- return(0);
- }
- na=sizeof(uint32)+69;
- nb=_TIFFmalloc(na);
- if (nb==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- *(uint32*)nb=na;
- nb[sizeof(uint32)]=255;
- 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)
- return(0);
- o=nb[sizeof(uint32)+4]&15;
- if (3<o)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
- return(0);
- }
- if (sp->qtable[o]!=0)
- _TIFFfree(sp->qtable[o]);
- sp->qtable[o]=nb;
- m-=65;
- } while(m>0);
- }
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
-{
- /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
- /* TODO: the following assumes there is only one table in this marker... but i'm not quite sure that assumption is guaranteed correct */
- static const char module[]="OJPEGReadHeaderInfoSecStreamDht";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint16 m;
- uint32 na;
- uint8* nb;
- uint8 o;
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- if (m<=2)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
- return(0);
- }
- if (sp->subsamplingcorrect!=0)
- {
- OJPEGReadSkip(sp,m-2);
- }
- else
- {
- na=sizeof(uint32)+2+m;
- nb=_TIFFmalloc(na);
- if (nb==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- *(uint32*)nb=na;
- nb[sizeof(uint32)]=255;
- nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
- nb[sizeof(uint32)+2]=(m>>8);
- nb[sizeof(uint32)+3]=(m&255);
- if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0)
- return(0);
- o=nb[sizeof(uint32)+4];
- if ((o&240)==0)
- {
- if (3<o)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
- return(0);
- }
- if (sp->dctable[o]!=0)
- _TIFFfree(sp->dctable[o]);
- sp->dctable[o]=nb;
- }
- else
- {
- if ((o&240)!=16)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
- return(0);
- }
- o&=15;
- if (3<o)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
- return(0);
- }
- if (sp->actable[o]!=0)
- _TIFFfree(sp->actable[o]);
- sp->actable[o]=nb;
- }
- }
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
-{
- /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
- static const char module[]="OJPEGReadHeaderInfoSecStreamSof";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint16 m;
- uint16 n;
- uint8 o;
- uint16 p;
- uint16 q;
- if (sp->sof_log!=0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
- return(0);
- }
- if (sp->subsamplingcorrect==0)
- sp->sof_marker_id=marker_id;
- /* Lf: data length */
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- if (m<11)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
- return(0);
- }
- m-=8;
- if (m%3!=0)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
- return(0);
- }
- n=m/3;
- if (sp->subsamplingcorrect==0)
- {
- if (n!=sp->samples_per_pixel)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of samples");
- return(0);
- }
- }
- /* P: Sample precision */
- if (OJPEGReadByte(sp,&o)==0)
- return(0);
- if (o!=8)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of bits per sample");
- return(0);
- }
- /* Y: Number of lines, X: Number of samples per line */
- if (sp->subsamplingcorrect)
- OJPEGReadSkip(sp,4);
- else
- {
- /* TODO: probably best to also add check on allowed upper bound, especially x, may cause buffer overflow otherwise i think */
- /* Y: Number of lines */
- if (OJPEGReadWord(sp,&p)==0)
- return(0);
- if ((p<sp->image_length) && (p<sp->strile_length_total))
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
- return(0);
- }
- sp->sof_y=p;
- /* X: Number of samples per line */
- if (OJPEGReadWord(sp,&p)==0)
- return(0);
- if ((p<sp->image_width) && (p<sp->strile_width))
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
- return(0);
- }
- sp->sof_x=p;
- }
- /* Nf: Number of image components in frame */
- if (OJPEGReadByte(sp,&o)==0)
- return(0);
- if (o!=n)
- {
- if (sp->subsamplingcorrect==0)
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
- return(0);
- }
- /* per component stuff */
- /* TODO: double-check that flow implies that n cannot be as big as to make us overflow sof_c, sof_hv and sof_tq arrays */
- for (q=0; q<n; q++)
- {
- /* C: Component identifier */
- if (OJPEGReadByte(sp,&o)==0)
- return(0);
- if (sp->subsamplingcorrect==0)
- sp->sof_c[q]=o;
- /* H: Horizontal sampling factor, and V: Vertical sampling factor */
- if (OJPEGReadByte(sp,&o)==0)
- return(0);
- if (sp->subsamplingcorrect!=0)
- {
- if (q==0)
- {
- sp->subsampling_hor=(o>>4);
- sp->subsampling_ver=(o&15);
- if (((sp->subsampling_hor!=1) && (sp->subsampling_hor!=2) && (sp->subsampling_hor!=4)) ||
- ((sp->subsampling_ver!=1) && (sp->subsampling_ver!=2) && (sp->subsampling_ver!=4)))
- sp->subsampling_force_desubsampling_inside_decompression=1;
- }
- else
- {
- if (o!=17)
- sp->subsampling_force_desubsampling_inside_decompression=1;
- }
- }
- else
- {
- sp->sof_hv[q]=o;
- if (sp->subsampling_force_desubsampling_inside_decompression==0)
- {
- if (q==0)
- {
- if (o!=((sp->subsampling_hor<<4)|sp->subsampling_ver))
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
- return(0);
- }
- }
- else
- {
- if (o!=17)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
- return(0);
- }
- }
- }
- }
- /* Tq: Quantization table destination selector */
- if (OJPEGReadByte(sp,&o)==0)
- return(0);
- if (sp->subsamplingcorrect==0)
- sp->sof_tq[q]=o;
- }
- if (sp->subsamplingcorrect==0)
- sp->sof_log=1;
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecStreamSos(TIFF* tif)
-{
- /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
- static const char module[]="OJPEGReadHeaderInfoSecStreamSos";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint16 m;
- uint8 n;
- uint8 o;
- assert(sp->subsamplingcorrect==0);
- if (sp->sof_log==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
- return(0);
- }
- /* Ls */
- if (OJPEGReadWord(sp,&m)==0)
- return(0);
- if (m!=6+sp->samples_per_pixel_per_plane*2)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
- return(0);
- }
- /* Ns */
- if (OJPEGReadByte(sp,&n)==0)
- return(0);
- if (n!=sp->samples_per_pixel_per_plane)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
- return(0);
- }
- /* Cs, Td, and Ta */
- for (o=0; o<sp->samples_per_pixel_per_plane; o++)
- {
- /* Cs */
- if (OJPEGReadByte(sp,&n)==0)
- return(0);
- sp->sos_cs[sp->plane_sample_offset+o]=n;
- /* Td and Ta */
- if (OJPEGReadByte(sp,&n)==0)
- return(0);
- sp->sos_tda[sp->plane_sample_offset+o]=n;
- }
- /* skip Ss, Se, Ah, en Al -> no check, as per Tom Lane recommendation, as per LibJpeg source */
- OJPEGReadSkip(sp,3);
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
-{
- static const char module[]="OJPEGReadHeaderInfoSecTablesQTable";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- uint8 n;
- uint32 oa;
- uint8* ob;
- uint32 p;
- if (sp->qtable_offset[0]==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
- return(0);
- }
- sp->in_buffer_file_pos_log=0;
- for (m=0; m<sp->samples_per_pixel; m++)
- {
- if ((sp->qtable_offset[m]!=0) && ((m==0) || (sp->qtable_offset[m]!=sp->qtable_offset[m-1])))
- {
- for (n=0; n<m-1; n++)
- {
- if (sp->qtable_offset[m]==sp->qtable_offset[n])
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegQTables tag value");
- return(0);
- }
- }
- oa=sizeof(uint32)+69;
- ob=_TIFFmalloc(oa);
- if (ob==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- *(uint32*)ob=oa;
- ob[sizeof(uint32)]=255;
- ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
- ob[sizeof(uint32)+2]=0;
- ob[sizeof(uint32)+3]=67;
- ob[sizeof(uint32)+4]=m;
- TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
- p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
- if (p!=64)
- return(0);
- sp->qtable[m]=ob;
- sp->sof_tq[m]=m;
- }
- else
- sp->sof_tq[m]=sp->sof_tq[m-1];
- }
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
-{
- static const char module[]="OJPEGReadHeaderInfoSecTablesDcTable";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- uint8 n;
- uint8 o[16];
- uint32 p;
- uint32 q;
- uint32 ra;
- uint8* rb;
- if (sp->dctable_offset[0]==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
- return(0);
- }
- sp->in_buffer_file_pos_log=0;
- for (m=0; m<sp->samples_per_pixel; m++)
- {
- if ((sp->dctable_offset[m]!=0) && ((m==0) || (sp->dctable_offset[m]!=sp->dctable_offset[m-1])))
- {
- for (n=0; n<m-1; n++)
- {
- if (sp->dctable_offset[m]==sp->dctable_offset[n])
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegDcTables tag value");
- return(0);
- }
- }
- TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
- p=TIFFReadFile(tif,o,16);
- if (p!=16)
- return(0);
- q=0;
- for (n=0; n<16; n++)
- q+=o[n];
- ra=sizeof(uint32)+21+q;
- rb=_TIFFmalloc(ra);
- if (rb==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- *(uint32*)rb=ra;
- rb[sizeof(uint32)]=255;
- rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
- rb[sizeof(uint32)+2]=((19+q)>>8);
- rb[sizeof(uint32)+3]=((19+q)&255);
- rb[sizeof(uint32)+4]=m;
- for (n=0; n<16; n++)
- rb[sizeof(uint32)+5+n]=o[n];
- p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
- if (p!=q)
- return(0);
- sp->dctable[m]=rb;
- sp->sos_tda[m]=(m<<4);
- }
- else
- sp->sos_tda[m]=sp->sos_tda[m-1];
- }
- return(1);
-}
-
-static int
-OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
-{
- static const char module[]="OJPEGReadHeaderInfoSecTablesAcTable";
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- uint8 n;
- uint8 o[16];
- uint32 p;
- uint32 q;
- uint32 ra;
- uint8* rb;
- if (sp->actable_offset[0]==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
- return(0);
- }
- sp->in_buffer_file_pos_log=0;
- for (m=0; m<sp->samples_per_pixel; m++)
- {
- if ((sp->actable_offset[m]!=0) && ((m==0) || (sp->actable_offset[m]!=sp->actable_offset[m-1])))
- {
- for (n=0; n<m-1; n++)
- {
- if (sp->actable_offset[m]==sp->actable_offset[n])
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegAcTables tag value");
- return(0);
- }
- }
- TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
- p=TIFFReadFile(tif,o,16);
- if (p!=16)
- return(0);
- q=0;
- for (n=0; n<16; n++)
- q+=o[n];
- ra=sizeof(uint32)+21+q;
- rb=_TIFFmalloc(ra);
- if (rb==0)
- {
- TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
- return(0);
- }
- *(uint32*)rb=ra;
- rb[sizeof(uint32)]=255;
- rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
- rb[sizeof(uint32)+2]=((19+q)>>8);
- rb[sizeof(uint32)+3]=((19+q)&255);
- rb[sizeof(uint32)+4]=(16|m);
- for (n=0; n<16; n++)
- rb[sizeof(uint32)+5+n]=o[n];
- p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
- if (p!=q)
- return(0);
- sp->actable[m]=rb;
- sp->sos_tda[m]=(sp->sos_tda[m]|m);
- }
- else
- sp->sos_tda[m]=(sp->sos_tda[m]|(sp->sos_tda[m-1]&15));
- }
- return(1);
-}
-
-static int
-OJPEGReadBufferFill(OJPEGState* sp)
-{
- uint16 m;
- tsize_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
- {
- if (sp->in_buffer_file_togo!=0)
- {
- if (sp->in_buffer_file_pos_log==0)
- {
- TIFFSeekFile(sp->tif,sp->in_buffer_file_pos,SEEK_SET);
- sp->in_buffer_file_pos_log=1;
- }
- m=OJPEG_BUFFER;
- if (m>sp->in_buffer_file_togo)
- m=(uint16)sp->in_buffer_file_togo;
- n=TIFFReadFile(sp->tif,sp->in_buffer,(tsize_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);
- m=(uint16)n;
- sp->in_buffer_togo=m;
- sp->in_buffer_cur=sp->in_buffer;
- sp->in_buffer_file_togo-=m;
- sp->in_buffer_file_pos+=m;
- break;
- }
- sp->in_buffer_file_pos_log=0;
- switch(sp->in_buffer_source)
- {
- case osibsNotSetYet:
- if (sp->jpeg_interchange_format!=0)
- {
- sp->in_buffer_file_pos=sp->jpeg_interchange_format;
- sp->in_buffer_file_togo=sp->jpeg_interchange_format_length;
- }
- sp->in_buffer_source=osibsJpegInterchangeFormat;
- break;
- case osibsJpegInterchangeFormat:
- sp->in_buffer_source=osibsStrile;
- case osibsStrile:
- if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
- sp->in_buffer_source=osibsEof;
- else
- {
- 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)
- sp->in_buffer_file_pos=0;
- else
- {
- 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)
- sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
- }
- }
- sp->in_buffer_next_strile++;
- }
- break;
- default:
- return(0);
- }
- } while (1);
- return(1);
-}
-
-static int
-OJPEGReadByte(OJPEGState* sp, uint8* byte)
-{
- if (sp->in_buffer_togo==0)
- {
- if (OJPEGReadBufferFill(sp)==0)
- return(0);
- assert(sp->in_buffer_togo>0);
- }
- *byte=*(sp->in_buffer_cur);
- sp->in_buffer_cur++;
- sp->in_buffer_togo--;
- return(1);
-}
-
-static int
-OJPEGReadBytePeek(OJPEGState* sp, uint8* byte)
-{
- if (sp->in_buffer_togo==0)
- {
- if (OJPEGReadBufferFill(sp)==0)
- return(0);
- assert(sp->in_buffer_togo>0);
- }
- *byte=*(sp->in_buffer_cur);
- return(1);
-}
+/* Alternate destination manager to output JPEGTables field: */
static void
-OJPEGReadByteAdvance(OJPEGState* sp)
-{
- assert(sp->in_buffer_togo>0);
- sp->in_buffer_cur++;
- sp->in_buffer_togo--;
-}
-
-static int
-OJPEGReadWord(OJPEGState* sp, uint16* word)
-{
- uint8 m;
- if (OJPEGReadByte(sp,&m)==0)
- return(0);
- *word=(m<<8);
- if (OJPEGReadByte(sp,&m)==0)
- return(0);
- *word|=m;
- return(1);
-}
+tables_init_destination(register j_compress_ptr cinfo)
+ {
+# define sp ((OJPEGState *)cinfo)
+ /* The "jpegtables_length" field is the allocated buffer size while building */
+ sp->dest.next_output_byte = (JOCTET *)sp->jpegtables;
+ sp->dest.free_in_buffer = (size_t)sp->jpegtables_length;
+# undef sp
+ }
-static int
-OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
-{
- uint16 mlen;
- uint8* mmem;
- uint16 n;
- assert(len>0);
- mlen=len;
- mmem=mem;
- do
- {
- if (sp->in_buffer_togo==0)
- {
- if (OJPEGReadBufferFill(sp)==0)
- return(0);
- assert(sp->in_buffer_togo>0);
- }
- n=mlen;
- if (n>sp->in_buffer_togo)
- n=sp->in_buffer_togo;
- _TIFFmemcpy(mmem,sp->in_buffer_cur,n);
- sp->in_buffer_cur+=n;
- sp->in_buffer_togo-=n;
- mlen-=n;
- mmem+=n;
- } while(mlen>0);
- return(1);
-}
+static boolean
+tables_empty_output_buffer(register j_compress_ptr cinfo)
+ { void *newbuf;
+# define sp ((OJPEGState *)cinfo)
+
+ /* The entire buffer has been filled, so enlarge it by 1000 bytes. */
+ if (!( newbuf = _TIFFrealloc( (tdata_t)sp->jpegtables
+ , (tsize_t)(sp->jpegtables_length + 1000)
+ )
+ )
+ ) ERREXIT1(cinfo,JERR_OUT_OF_MEMORY,100);
+ sp->dest.next_output_byte = (JOCTET *)newbuf + sp->jpegtables_length;
+ sp->dest.free_in_buffer = (size_t)1000;
+ sp->jpegtables = newbuf;
+ sp->jpegtables_length += 1000;
+ return TRUE;
+# undef sp
+ }
static void
-OJPEGReadSkip(OJPEGState* sp, uint16 len)
-{
- uint16 m;
- uint16 n;
- m=len;
- n=m;
- if (n>sp->in_buffer_togo)
- n=sp->in_buffer_togo;
- sp->in_buffer_cur+=n;
- sp->in_buffer_togo-=n;
- m-=n;
- if (m>0)
- {
- assert(sp->in_buffer_togo==0);
- n=m;
- if (n>sp->in_buffer_file_togo)
- n=sp->in_buffer_file_togo;
- sp->in_buffer_file_pos+=n;
- sp->in_buffer_file_togo-=n;
- sp->in_buffer_file_pos_log=0;
- /* we don't skip past jpeginterchangeformat/strile block...
- * if that is asked from us, we're dealing with totally bazurk
- * data anyway, and we've not seen this happening on any
- * testfile, so we might as well likely cause some other
- * meaningless error to be passed at some later time
- */
- }
-}
+tables_term_destination(register j_compress_ptr cinfo)
+ {
+# define sp ((OJPEGState *)cinfo)
+ /* Set tables length to no. of Bytes actually emitted. */
+ sp->jpegtables_length -= sp->dest.free_in_buffer;
+# undef sp
+ }
+
+/*ARGSUSED*/ static int
+TIFFojpeg_tables_dest(register OJPEGState *sp, TIFF *tif)
+ {
+
+ /* Allocate a working buffer for building tables. The initial size is 1000
+ Bytes, which is usually adequate.
+ */
+ if (sp->jpegtables) _TIFFfree(sp->jpegtables);
+ if (!(sp->jpegtables = (void*)
+ _TIFFmalloc((tsize_t)(sp->jpegtables_length = 1000))
+ )
+ )
+ {
+ sp->jpegtables_length = 0;
+ TIFFError("TIFFojpeg_tables_dest",no_jtable_space);
+ return 0;
+ };
+ sp->cinfo.c.dest = &sp->dest;
+ sp->dest.init_destination = tables_init_destination;
+ sp->dest.empty_output_buffer = tables_empty_output_buffer;
+ sp->dest.term_destination = tables_term_destination;
+ return 1;
+ }
+#else /* well, hardly ever */
static int
-OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- *len=0;
- do
- {
- assert(sp->out_state<=ososEoi);
- switch(sp->out_state)
- {
- case ososSoi:
- OJPEGWriteStreamSoi(tif,mem,len);
- break;
- case ososQTable0:
- OJPEGWriteStreamQTable(tif,0,mem,len);
- break;
- case ososQTable1:
- OJPEGWriteStreamQTable(tif,1,mem,len);
- break;
- case ososQTable2:
- OJPEGWriteStreamQTable(tif,2,mem,len);
- break;
- case ososQTable3:
- OJPEGWriteStreamQTable(tif,3,mem,len);
- break;
- case ososDcTable0:
- OJPEGWriteStreamDcTable(tif,0,mem,len);
- break;
- case ososDcTable1:
- OJPEGWriteStreamDcTable(tif,1,mem,len);
- break;
- case ososDcTable2:
- OJPEGWriteStreamDcTable(tif,2,mem,len);
- break;
- case ososDcTable3:
- OJPEGWriteStreamDcTable(tif,3,mem,len);
- break;
- case ososAcTable0:
- OJPEGWriteStreamAcTable(tif,0,mem,len);
- break;
- case ososAcTable1:
- OJPEGWriteStreamAcTable(tif,1,mem,len);
- break;
- case ososAcTable2:
- OJPEGWriteStreamAcTable(tif,2,mem,len);
- break;
- case ososAcTable3:
- OJPEGWriteStreamAcTable(tif,3,mem,len);
- break;
- case ososDri:
- OJPEGWriteStreamDri(tif,mem,len);
- break;
- case ososSof:
- OJPEGWriteStreamSof(tif,mem,len);
- break;
- case ososSos:
- OJPEGWriteStreamSos(tif,mem,len);
- break;
- case ososCompressed:
- if (OJPEGWriteStreamCompressed(tif,mem,len)==0)
- return(0);
- break;
- case ososRst:
- OJPEGWriteStreamRst(tif,mem,len);
- break;
- case ososEoi:
- OJPEGWriteStreamEoi(tif,mem,len);
- break;
- }
- } while (*len==0);
- return(1);
-}
+_notSupported(register TIFF *tif)
+ { const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
-static void
-OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(OJPEG_BUFFER>=2);
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=JPEG_MARKER_SOI;
- *len=2;
- *mem=(void*)sp->out_buffer;
- sp->out_state++;
-}
-
-static void
-OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- if (sp->qtable[table_index]!=0)
- {
- *mem=(void*)(sp->qtable[table_index]+sizeof(uint32));
- *len=*((uint32*)sp->qtable[table_index])-sizeof(uint32);
- }
- sp->out_state++;
-}
-
-static void
-OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- if (sp->dctable[table_index]!=0)
- {
- *mem=(void*)(sp->dctable[table_index]+sizeof(uint32));
- *len=*((uint32*)sp->dctable[table_index])-sizeof(uint32);
- }
- sp->out_state++;
-}
+ TIFFError(tif->tif_name,"%s compression not supported",c->name);
+ return 0;
+ }
+#endif /* never */
+/* The following subroutines comprise a JPEG Library "source" data manager by
+ by directing compressed data to the JPEG Library from a TIFF Library input
+ buffer.
+*/
static void
-OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- if (sp->actable[table_index]!=0)
- {
- *mem=(void*)(sp->actable[table_index]+sizeof(uint32));
- *len=*((uint32*)sp->actable[table_index])-sizeof(uint32);
- }
- sp->out_state++;
-}
+std_init_source(register j_decompress_ptr cinfo)
+ {
+# define sp ((OJPEGState *)cinfo)
+ register TIFF *tif = sp->tif;
+
+ if (sp->src.bytes_in_buffer == 0)
+ {
+ sp->src.next_input_byte = (const JOCTET *)tif->tif_rawdata;
+ sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
+ };
+# undef sp
+ }
-static void
-OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(OJPEG_BUFFER>=6);
- if (sp->restart_interval!=0)
- {
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=JPEG_MARKER_DRI;
- sp->out_buffer[2]=0;
- sp->out_buffer[3]=4;
- sp->out_buffer[4]=(sp->restart_interval>>8);
- sp->out_buffer[5]=(sp->restart_interval&255);
- *len=6;
- *mem=(void*)sp->out_buffer;
- }
- sp->out_state++;
-}
+static boolean
+std_fill_input_buffer(register j_decompress_ptr cinfo)
+ { static const JOCTET dummy_EOI[2]={0xFF,JPEG_EOI};
+# define sp ((OJPEGState *)cinfo)
-static void
-OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- assert(OJPEG_BUFFER>=2+8+sp->samples_per_pixel_per_plane*3);
- assert(255>=8+sp->samples_per_pixel_per_plane*3);
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=sp->sof_marker_id;
- /* Lf */
- sp->out_buffer[2]=0;
- sp->out_buffer[3]=8+sp->samples_per_pixel_per_plane*3;
- /* P */
- sp->out_buffer[4]=8;
- /* Y */
- sp->out_buffer[5]=(sp->sof_y>>8);
- sp->out_buffer[6]=(sp->sof_y&255);
- /* X */
- sp->out_buffer[7]=(sp->sof_x>>8);
- sp->out_buffer[8]=(sp->sof_x&255);
- /* Nf */
- sp->out_buffer[9]=sp->samples_per_pixel_per_plane;
- for (m=0; m<sp->samples_per_pixel_per_plane; m++)
- {
- /* C */
- sp->out_buffer[10+m*3]=sp->sof_c[sp->plane_sample_offset+m];
- /* H and V */
- sp->out_buffer[10+m*3+1]=sp->sof_hv[sp->plane_sample_offset+m];
- /* Tq */
- sp->out_buffer[10+m*3+2]=sp->sof_tq[sp->plane_sample_offset+m];
- }
- *len=10+sp->samples_per_pixel_per_plane*3;
- *mem=(void*)sp->out_buffer;
- sp->out_state++;
-}
+ /* Control should never get here, since an entire strip/tile is read into
+ memory before the decompressor is called; thus, data should have been
+ supplied by the "init_source" method. ...But, sometimes things fail.
+ */
+ WARNMS(cinfo,JWRN_JPEG_EOF);
+ sp->src.next_input_byte = dummy_EOI; /* Insert a fake EOI marker */
+ sp->src.bytes_in_buffer = sizeof dummy_EOI;
+ return TRUE;
+# undef sp
+ }
static void
-OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- uint8 m;
- assert(OJPEG_BUFFER>=2+6+sp->samples_per_pixel_per_plane*2);
- assert(255>=6+sp->samples_per_pixel_per_plane*2);
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=JPEG_MARKER_SOS;
- /* Ls */
- sp->out_buffer[2]=0;
- sp->out_buffer[3]=6+sp->samples_per_pixel_per_plane*2;
- /* Ns */
- sp->out_buffer[4]=sp->samples_per_pixel_per_plane;
- for (m=0; m<sp->samples_per_pixel_per_plane; m++)
- {
- /* Cs */
- sp->out_buffer[5+m*2]=sp->sos_cs[sp->plane_sample_offset+m];
- /* Td and Ta */
- sp->out_buffer[5+m*2+1]=sp->sos_tda[sp->plane_sample_offset+m];
- }
- /* Ss */
- sp->out_buffer[5+sp->samples_per_pixel_per_plane*2]=0;
- /* Se */
- sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+1]=63;
- /* Ah and Al */
- sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+2]=0;
- *len=8+sp->samples_per_pixel_per_plane*2;
- *mem=(void*)sp->out_buffer;
- sp->out_state++;
-}
-
+std_skip_input_data(register j_decompress_ptr cinfo, long num_bytes)
+ {
+# define sp ((OJPEGState *)cinfo)
+
+ if (num_bytes > 0)
+ {
+ if (num_bytes > (long)sp->src.bytes_in_buffer) /* oops: buffer overrun */
+ (void)std_fill_input_buffer(cinfo);
+ else
+ {
+ sp->src.next_input_byte += (size_t)num_bytes;
+ sp->src.bytes_in_buffer -= (size_t)num_bytes;
+ }
+ }
+# undef sp
+ }
+
+/*ARGSUSED*/ static void
+std_term_source(register j_decompress_ptr cinfo){} /* "Dummy" stub */
+
+/* Allocate temporary I/O buffers for downsampled data, using values computed in
+ "jpeg_start_{de}compress()". We use the JPEG Library's allocator so that
+ buffers will be released automatically when done with a strip/tile. This is
+ also a handy place to compute samplesperclump, bytesperline, etc.
+*/
static int
-OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- if (sp->in_buffer_togo==0)
- {
- if (OJPEGReadBufferFill(sp)==0)
- return(0);
- assert(sp->in_buffer_togo>0);
- }
- *len=sp->in_buffer_togo;
- *mem=(void*)sp->in_buffer_cur;
- sp->in_buffer_togo=0;
- if (sp->in_buffer_file_togo==0)
- {
- switch(sp->in_buffer_source)
- {
- case osibsStrile:
- if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
- sp->out_state=ososRst;
- else
- sp->out_state=ososEoi;
- break;
- case osibsEof:
- sp->out_state=ososEoi;
- break;
- default:
- break;
- }
- }
- return(1);
-}
-
-static void
-OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(OJPEG_BUFFER>=2);
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=JPEG_MARKER_RST0+sp->restart_index;
- sp->restart_index++;
- if (sp->restart_index==8)
- sp->restart_index=0;
- *len=2;
- *mem=(void*)sp->out_buffer;
- sp->out_state=ososCompressed;
-}
-
-static void
-OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- assert(OJPEG_BUFFER>=2);
- sp->out_buffer[0]=255;
- sp->out_buffer[1]=JPEG_MARKER_EOI;
- *len=2;
- *mem=(void*)sp->out_buffer;
-}
+alloc_downsampled_buffers(TIFF *tif,jpeg_component_info *comp_info,
+ int num_components)
+ { register OJPEGState *sp = OJState(tif);
+
+ sp->samplesperclump = 0;
+ if (num_components > 0)
+ { tsize_t size = sp->cinfo.comm.is_decompressor
+# ifdef D_LOSSLESS_SUPPORTED
+ ? sp->cinfo.d.min_codec_data_unit
+# else
+ ? DCTSIZE
+# endif
+# ifdef C_LOSSLESS_SUPPORTED
+ : sp->cinfo.c.data_unit;
+# else
+ : DCTSIZE;
+# endif
+ int ci = 0;
+ register jpeg_component_info *compptr = comp_info;
+
+ do
+ { JSAMPARRAY buf;
+
+ sp->samplesperclump +=
+ compptr->h_samp_factor * compptr->v_samp_factor;
+# if defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED)
+ if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_data_units*size,compptr->v_samp_factor*size))))
+# else
+ if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_blocks*size,compptr->v_samp_factor*size))))
+# endif
+ return 0;
+ sp->ds_buffer[ci] = buf;
+ }
+ while (++compptr,++ci < num_components);
+ };
+ return 1;
+ }
+#ifdef never
+
+/* JPEG Encoding begins here. */
+
+/*ARGSUSED*/ static int
+OJPEGEncode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
+ { tsize_t rows; /* No. of unprocessed rows in file */
+ register OJPEGState *sp = OJState(tif);
+
+ /* Encode a chunk of pixels, where returned data is NOT down-sampled (the
+ standard case). The data is expected to be written in scan-line multiples.
+ */
+ if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
+ if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
+ > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
+ ) cc = rows;
+ while (--cc >= 0)
+ {
+ if ( CALLJPEG(sp,-1,jpeg_write_scanlines(&sp->cinfo.c,(JSAMPARRAY)&buf,1))
+ != 1
+ ) return 0;
+ ++tif->tif_row;
+ buf += sp->bytesperline;
+ };
+ return 1;
+ }
+
+/*ARGSUSED*/ static int
+OJPEGEncodeRaw(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
+ { tsize_t rows; /* No. of unprocessed rows in file */
+ JDIMENSION lines_per_MCU, size;
+ register OJPEGState *sp = OJState(tif);
+
+ /* Encode a chunk of pixels, where returned data is down-sampled as per the
+ sampling factors. The data is expected to be written in scan-line
+ multiples.
+ */
+ cc /= sp->bytesperline;
+ if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
+ if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
+ > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
+ ) cc = rows;
+# ifdef C_LOSSLESS_SUPPORTED
+ lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = sp->cinfo.d.data_unit);
+# else
+ lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = DCTSIZE);
+# endif
+ while (--cc >= 0)
+ { int ci = 0, clumpoffset = 0;
+ register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
+
+ /* The fastest way to separate the data is to make 1 pass over the scan
+ line for each row of each component.
+ */
+ do
+ { int ypos = 0;
+
+ do
+ { int padding;
+ register JSAMPLE *inptr = (JSAMPLE*)buf + clumpoffset,
+ *outptr =
+ sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos];
+ /* Cb,Cr both have sampling factors 1, so this is correct */
+ register int clumps_per_line =
+ sp->cinfo.c.comp_info[1].downsampled_width,
+ xpos;
+
+ padding = (int)
+# ifdef C_LOSSLESS_SUPPORTED
+ ( compptr->width_in_data_units * size
+# else
+ ( compptr->width_in_blocks * size
+# endif
+ - clumps_per_line * compptr->h_samp_factor
+ );
+ if (compptr->h_samp_factor == 1) /* Cb & Cr fast path */
+ do *outptr++ = *inptr;
+ while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
+ else /* general case */
+ do
+ {
+ xpos = 0;
+ do *outptr++ = inptr[xpos];
+ while (++xpos < compptr->h_samp_factor);
+ }
+ while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
+ xpos = 0; /* Pad each scan line as needed */
+ do outptr[0] = outptr[-1]; while (++outptr,++xpos < padding);
+ clumpoffset += compptr->h_samp_factor;
+ }
+ while (++ypos < compptr->v_samp_factor);
+ }
+ while (++compptr,++ci < sp->cinfo.c.num_components);
+ if (++sp->scancount >= size)
+ {
+ if ( CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,lines_per_MCU))
+ != lines_per_MCU
+ ) return 0;
+ sp->scancount = 0;
+ };
+ ++tif->tif_row++
+ buf += sp->bytesperline;
+ };
+ return 1;
+ }
-#ifndef LIBJPEG_ENCAP_EXTERNAL
static int
-jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
-{
- return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_create_decompress(cinfo),1));
-}
-#endif
+OJPEGSetupEncode(register TIFF *tif)
+ { static const char module[]={"OJPEGSetupEncode"};
+ uint32 segment_height, segment_width;
+ int status = 1; /* Assume success by default */
+ register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ /* Verify miscellaneous parameters. This will need work if the TIFF Library
+ ever supports different depths for different components, or if the JPEG
+ Library ever supports run-time depth selection. Neither seems imminent.
+ */
+ if (td->td_bitspersample != 8)
+ {
+ TIFFError(module,bad_bps,td->td_bitspersample);
+ status = 0;
+ };
+
+ /* The TIFF Version 6.0 specification and IJG JPEG Library accept different
+ sets of color spaces, so verify that our image belongs to the common subset
+ and map its photometry code, then initialize to handle subsampling and
+ optional JPEG Library YCbCr <-> RGB color-space conversion.
+ */
+ switch (td->td_photometric)
+ {
+ case PHOTOMETRIC_YCBCR :
+
+ /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
+ TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
+ */
+ if ( ( td->td_ycbcrsubsampling[0] == 1
+ || td->td_ycbcrsubsampling[0] == 2
+ || td->td_ycbcrsubsampling[0] == 4
+ )
+ && ( td->td_ycbcrsubsampling[1] == 1
+ || td->td_ycbcrsubsampling[1] == 2
+ || td->td_ycbcrsubsampling[1] == 4
+ )
+ )
+ sp->cinfo.c.raw_data_in =
+ ( (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
+ | (sp->v_sampling = td->td_ycbcrsubsampling[1])
+ ) != 011;
+ else
+ {
+ TIFFError(module,bad_subsampling);
+ status = 0;
+ };
+
+ /* A ReferenceBlackWhite field MUST be present, since the default value
+ is inapproriate for YCbCr. Fill in the proper value if the
+ application didn't set it.
+ */
+ if (!TIFFFieldSet(tif,FIELD_REFBLACKWHITE))
+ { float refbw[6];
+ long top = 1L << td->td_bitspersample;
+
+ refbw[0] = 0;
+ refbw[1] = (float)(top-1L);
+ refbw[2] = (float)(top>>1);
+ refbw[3] = refbw[1];
+ refbw[4] = refbw[2];
+ refbw[5] = refbw[1];
+ TIFFSetField(tif,TIFFTAG_REFERENCEBLACKWHITE,refbw);
+ };
+ sp->cinfo.c.jpeg_color_space = JCS_YCbCr;
+ if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
+ {
+ sp->cinfo.c.raw_data_in = FALSE;
+ sp->in_color_space = JCS_RGB;
+ break;
+ };
+ goto L2;
+ case PHOTOMETRIC_MINISBLACK:
+ sp->cinfo.c.jpeg_color_space = JCS_GRAYSCALE;
+ goto L1;
+ case PHOTOMETRIC_RGB :
+ sp->cinfo.c.jpeg_color_space = JCS_RGB;
+ goto L1;
+ case PHOTOMETRIC_SEPARATED :
+ sp->cinfo.c.jpeg_color_space = JCS_CMYK;
+ L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
+ L2: sp->cinfo.d.in_color_space = sp->cinfo.d.jpeg_color-space;
+ break;
+ default :
+ TIFFError(module,bad_photometry,td->td_photometric);
+ status = 0;
+ };
+ tif->tif_encoderow = tif->tif_encodestrip = tif->tif_encodetile =
+ sp->cinfo.c.raw_data_in ? OJPEGEncodeRaw : OJPEGEncode;
+ if (isTiled(tif))
+ { tsize_t size;
+
+# ifdef C_LOSSLESS_SUPPORTED
+ if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
+# else
+ if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
+# endif
+ if ((segment_height = td->td_tilelength) % size)
+ {
+ TIFFError(module,"JPEG tile height must be multiple of %d",size);
+ status = 0;
+ };
+# ifdef C_LOSSLESS_SUPPORTED
+ if ((size = sp->h_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
+# else
+ if ((size = sp->h_sampling*DCTSIZE) < 16) size = 16;
+# endif
+ if ((segment_width = td->td_tilewidth) % size)
+ {
+ TIFFError(module,"JPEG tile width must be multiple of %d",size);
+ status = 0;
+ };
+ sp->bytesperline = TIFFTileRowSize(tif);
+ }
+ else
+ { tsize_t size;
+
+# ifdef C_LOSSLESS_SUPPORTED
+ if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
+# else
+ if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
+# endif
+ if (td->td_rowsperstrip < (segment_height = td->td_imagelength))
+ {
+ if (td->td_rowsperstrip % size)
+ {
+ TIFFError(module,"JPEG RowsPerStrip must be multiple of %d",size);
+ status = 0;
+ };
+ segment_height = td->td_rowsperstrip;
+ };
+ segment_width = td->td_imagewidth;
+ sp->bytesperline = tif->tif_scanlinesize;
+ };
+ if (segment_width > 65535 || segment_height > 65535)
+ {
+ TIFFError(module,"Strip/tile too large for JPEG");
+ status = 0;
+ };
+
+ /* Initialize all JPEG parameters to default values. Note that the JPEG
+ Library's "jpeg_set_defaults()" method needs legal values for the
+ "in_color_space" and "input_components" fields.
+ */
+ sp->cinfo.c.input_components = 1; /* Default for JCS_UNKNOWN */
+ if (!CALLVJPEG(sp,jpeg_set_defaults(&sp->cinfo.c))) status = 0;
+ switch (sp->jpegtablesmode & (JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT))
+ { register JHUFF_TBL *htbl;
+ register JQUANT_TBL *qtbl;
+
+ case 0 :
+ sp->cinfo.c.optimize_coding = TRUE;
+ case JPEGTABLESMODE_HUFF :
+ if (!CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE)))
+ return 0;
+ if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
+ if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1]) qtbl->sent_table = FALSE;
+ goto L3;
+ case JPEGTABLESMODE_QUANT :
+ sp->cinfo.c.optimize_coding = TRUE;
+
+ /* We do not support application-supplied JPEG tables, so mark the field
+ "not present".
+ */
+ L3: TIFFClrFieldBit(tif,FIELD_JPEGTABLES);
+ break;
+ case JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT:
+ if ( !CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE))
+ || !CALLVJPEG(sp,jpeg_suppress_tables(&sp->cinfo.c,TRUE))
+ )
+ {
+ status = 0;
+ break;
+ };
+ if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
+ if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
+ if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
+ if (sp->cinfo.c.jpeg_color_space == JCS_YCbCr)
+ {
+ if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1])
+ qtbl->sent_table = FALSE;
+ if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[1])
+ htbl->sent_table = FALSE;
+ if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[1])
+ htbl->sent_table = FALSE;
+ };
+ if ( TIFFojpeg_tables_dest(sp,tif)
+ && CALLVJPEG(sp,jpeg_write_tables(&sp->cinfo.c))
+ )
+ {
+
+ /* Mark the field "present". We can't use "TIFFSetField()" because
+ "BEENWRITING" is already set!
+ */
+ TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
+ tif->tif_flags |= TIFF_DIRTYDIRECT;
+ }
+ else status = 0;
+ };
+ if ( sp->cinfo.c.raw_data_in
+ && !alloc_downsampled_buffers(tif,sp->cinfo.c.comp_info,
+ sp->cinfo.c.num_components)
+ ) status = 0;
+ if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
+ /* Grab parameters that are same for all strips/tiles. */
+
+ sp->dest.init_destination = std_init_destination;
+ sp->dest.empty_output_buffer = std_empty_output_buffer;
+ sp->dest.term_destination = std_term_destination;
+ sp->cinfo.c.dest = &sp->dest;
+ sp->cinfo.c.data_precision = td->td_bitspersample;
+ sp->cinfo.c.write_JFIF_header = /* Don't write extraneous markers */
+ sp->cinfo.c.write_Adobe_marker = FALSE;
+ sp->cinfo.c.image_width = segment_width;
+ sp->cinfo.c.image_height = segment_height;
+ sp->cinfo.c.comp_info[0].h_samp_factor =
+ sp->cinfo.c.comp_info[0].v_samp_factor = 1;
+ return CALLVJPEG(sp,jpeg_start_compress(&sp->cinfo.c,FALSE));
+# undef td
+ }
-#ifndef LIBJPEG_ENCAP_EXTERNAL
static int
-jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image)
-{
- return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_header(cinfo,require_image),1));
-}
-#endif
+OJPEGPreEncode(register TIFF *tif,tsample_t s)
+ { register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ /* If we are about to write the first row of an image plane, which should
+ coincide with a JPEG "scan", reset the JPEG Library's compressor. Otherwise
+ let the compressor run "as is" and return a "success" status without further
+ ado.
+ */
+ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
+ % td->td_stripsperimage
+ == 0
+ )
+ {
+ if ( (sp->cinfo.c.comp_info[0].component_id = s) == 1)
+ && sp->cinfo.c.jpeg_color_space == JCS_YCbCr
+ )
+ {
+ sp->cinfo.c.comp_info[0].quant_tbl_no =
+ sp->cinfo.c.comp_info[0].dc_tbl_no =
+ sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
+ sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
+ sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
+
+ /* Scale expected strip/tile size to match a downsampled component. */
+
+ sp->cinfo.c.image_width = TIFFhowmany(segment_width,sp->h_sampling);
+ sp->cinfo.c.image_height=TIFFhowmany(segment_height,sp->v_sampling);
+ };
+ sp->scancount = 0; /* Mark subsampling buffer(s) empty */
+ };
+ return 1;
+# undef td
+ }
-#ifndef LIBJPEG_ENCAP_EXTERNAL
static int
-jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
-{
- return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_start_decompress(cinfo),1));
-}
-#endif
+OJPEGPostEncode(register TIFF *tif)
+ { register OJPEGState *sp = OJState(tif);
+
+ /* Finish up at the end of a strip or tile. */
+
+ if (sp->scancount > 0) /* emit partial buffer of down-sampled data */
+ { JDIMENSION n;
+
+# ifdef C_LOSSLESS_SUPPORTED
+ if ( sp->scancount < sp->cinfo.c.data_unit
+ && sp->cinfo.c.num_components > 0
+ )
+# else
+ if (sp->scancount < DCTSIZE && sp->cinfo.c.num_components > 0)
+# endif
+ { int ci = 0, /* Pad the data vertically */
+# ifdef C_LOSSLESS_SUPPORTED
+ size = sp->cinfo.c.data_unit;
+# else
+ size = DCTSIZE;
+# endif
+ register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
+
+ do
+# ifdef C_LOSSLESS_SUPPORTED
+ { tsize_t row_width = compptr->width_in_data_units
+# else
+ tsize_t row_width = compptr->width_in_blocks
+# endif
+ *size*sizeof(JSAMPLE);
+ int ypos = sp->scancount*compptr->v_samp_factor;
+
+ do _TIFFmemcpy( (tdata_t)sp->ds_buffer[ci][ypos]
+ , (tdata_t)sp->ds_buffer[ci][ypos-1]
+ , row_width
+ );
+ while (++ypos < compptr->v_samp_factor*size);
+ }
+ while (++compptr,++ci < sp->cinfo.c.num_components);
+ };
+ n = sp->cinfo.c.max_v_samp_factor*size;
+ if (CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,n)) != n)
+ return 0;
+ };
+ return CALLVJPEG(sp,jpeg_finish_compress(&sp->cinfo.c));
+ }
+#endif /* never */
+
+/* JPEG Decoding begins here. */
+
+/*ARGSUSED*/ static int
+OJPEGDecode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
+ { tsize_t bytesperline = isTiled(tif)
+ ? TIFFTileRowSize(tif)
+ : tif->tif_scanlinesize,
+ rows; /* No. of unprocessed rows in file */
+ register OJPEGState *sp = OJState(tif);
+
+ /* Decode a chunk of pixels, where the input data has not NOT been down-
+ sampled, or else the TIFF Library's client has used the "JPEGColorMode" TIFF
+ pseudo-tag to request that the JPEG Library do color-space conversion; this
+ is the normal case. The data is expected to be read in scan-line multiples,
+ and this subroutine is called for both pixel-interleaved and separate color
+ planes.
+
+ WARNING: Unlike "OJPEGDecodeRawContig()", below, the no. of Bytes in each
+ decoded row is calculated here as "bytesperline" instead of
+ using "sp->bytesperline", which might be a little smaller. This can
+ occur for an old tiled image whose width isn't a multiple of 8 pixels.
+ That's illegal according to the TIFF Version 6 specification, but some
+ test files, like "zackthecat.tif", were built that way. In those cases,
+ we want to embed the image's true width in our caller's buffer (which is
+ presumably allocated according to the expected tile width) by
+ effectively "padding" it with unused Bytes at the end of each row.
+ */
+ if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
+ > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
+ ) cc = rows;
+ while (--cc >= 0)
+ {
+ if ( CALLJPEG(sp,-1,jpeg_read_scanlines(&sp->cinfo.d,(JSAMPARRAY)&buf,1))
+ != 1
+ ) return 0;
+ buf += bytesperline;
+ ++tif->tif_row;
+ };
+
+ /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
+ Imaging for Windows application, the DC coefficients of
+ each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
+ "strip", and any JPEG data bits remaining in the current Byte of the
+ decoder's input buffer must be discarded. To do so, we create an "ad hoc"
+ interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
+ "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
+ invoke that interface here after decoding each "strip".
+ */
+ if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
+ return 1;
+ }
+
+/*ARGSUSED*/ static int
+OJPEGDecodeRawContig(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
+ { tsize_t rows; /* No. of unprocessed rows in file */
+ JDIMENSION lines_per_MCU, size;
+ register OJPEGState *sp = OJState(tif);
+
+ /* Decode a chunk of pixels, where the input data has pixel-interleaved color
+ planes, some of which have been down-sampled, but the TIFF Library's client
+ has NOT used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG
+ Library do color-space conversion. In other words, we must up-sample/
+ expand/duplicate image components according to the image's sampling factors,
+ without changing its color space. The data is expected to be read in scan-
+ line multiples.
+ */
+ if ( (cc /= sp->bytesperline) /* No. of complete rows in caller's buffer */
+ > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
+ ) cc = rows;
+ lines_per_MCU = sp->cinfo.d.max_v_samp_factor
+# ifdef D_LOSSLESS_SUPPORTED
+ * (size = sp->cinfo.d.min_codec_data_unit);
+# else
+ * (size = DCTSIZE);
+# endif
+ while (--cc >= 0)
+ { int clumpoffset, ci;
+ register jpeg_component_info *compptr;
+
+ if (sp->scancount >= size) /* reload downsampled-data buffers */
+ {
+ if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
+ != lines_per_MCU
+ ) return 0;
+ sp->scancount = 0;
+ };
+
+ /* The fastest way to separate the data is: make 1 pass over the scan
+ line for each row of each component.
+ */
+ clumpoffset = ci = 0;
+ compptr = sp->cinfo.d.comp_info;
+ do
+ { int ypos = 0;
+
+ if (compptr->h_samp_factor == 1) /* fast path */
+ do
+ { register JSAMPLE *inptr =
+ sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
+ *outptr = (JSAMPLE *)buf + clumpoffset;
+ register int clumps_per_line = compptr->downsampled_width;
+
+ do *outptr = *inptr++;
+ while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
+ }
+ while ( (clumpoffset += compptr->h_samp_factor)
+ , ++ypos < compptr->v_samp_factor
+ );
+ else /* general case */
+ do
+ { register JSAMPLE *inptr =
+ sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
+ *outptr = (JSAMPLE *)buf + clumpoffset;
+ register int clumps_per_line = compptr->downsampled_width;
+
+ do
+ { register int xpos = 0;
+
+ do outptr[xpos] = *inptr++;
+ while (++xpos < compptr->h_samp_factor);
+ }
+ while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
+ }
+ while ( (clumpoffset += compptr->h_samp_factor)
+ , ++ypos < compptr->v_samp_factor
+ );
+ }
+ while (++compptr,++ci < sp->cinfo.d.num_components);
+ ++sp->scancount;
+ buf += sp->bytesperline;
+ ++tif->tif_row;
+ };
+
+ /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
+ Imaging for Windows application, the DC coefficients of
+ each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
+ "strip", and any JPEG data bits remaining in the current Byte of the
+ decoder's input buffer must be discarded. To do so, we create an "ad hoc"
+ interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
+ "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
+ invoke that interface here after decoding each "strip".
+ */
+ if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
+ return 1;
+ }
+
+/*ARGSUSED*/ static int
+OJPEGDecodeRawSeparate(TIFF *tif,register tidata_t buf,tsize_t cc,tsample_t s)
+ { tsize_t rows; /* No. of unprocessed rows in file */
+ JDIMENSION lines_per_MCU,
+ size, /* ...of MCU */
+ v; /* Component's vertical up-sampling ratio */
+ register OJPEGState *sp = OJState(tif);
+ register jpeg_component_info *compptr = sp->cinfo.d.comp_info + s;
+
+ /* Decode a chunk of pixels, where the input data has separate color planes,
+ some of which have been down-sampled, but the TIFF Library's client has NOT
+ used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library
+ do color-space conversion. The data is expected to be read in scan-line
+ multiples.
+ */
+ v = sp->cinfo.d.max_v_samp_factor/compptr->v_samp_factor;
+ if ( (cc /= compptr->downsampled_width) /* No. of rows in caller's buffer */
+ > (rows = (sp->cinfo.d.output_height-sp->cinfo.d.output_scanline+v-1)/v)
+ ) cc = rows; /* No. of rows of "clumps" to read */
+ lines_per_MCU = sp->cinfo.d.max_v_samp_factor
+# ifdef D_LOSSLESS_SUPPORTED
+ * (size = sp->cinfo.d.min_codec_data_unit);
+# else
+ * (size = DCTSIZE);
+# endif
+ L: if (sp->scancount >= size) /* reload downsampled-data buffers */
+ {
+ if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
+ != lines_per_MCU
+ ) return 0;
+ sp->scancount = 0;
+ };
+ rows = 0;
+ do
+ { register JSAMPLE *inptr =
+ sp->ds_buffer[s][sp->scancount*compptr->v_samp_factor + rows];
+ register int clumps_per_line = compptr->downsampled_width;
+
+ do *buf++ = *inptr++; while (--clumps_per_line > 0); /* Copy scanline */
+ tif->tif_row += v;
+ if (--cc <= 0) return 1; /* End of caller's buffer? */
+ }
+ while (++rows < compptr->v_samp_factor);
+ ++sp->scancount;
+ goto L;
+ }
+
+/* "OJPEGSetupDecode()" temporarily forces the JPEG Library to use the following
+ subroutine as a "dummy" input reader in order to fool the library into
+ thinking that it has read the image's first "Start of Scan" (SOS) marker, so
+ that it initializes accordingly.
+*/
+/*ARGSUSED*/ METHODDEF(int)
+fake_SOS_marker(j_decompress_ptr cinfo){return JPEG_REACHED_SOS;}
+
+/*ARGSUSED*/ METHODDEF(int)
+suspend(j_decompress_ptr cinfo){return JPEG_SUSPENDED;}
+
+/* The JPEG Library's "null" color-space converter actually re-packs separate
+ color planes (it's native image representation) into a pixel-interleaved,
+ contiguous plane. But if our TIFF Library client is tryng to process a
+ PLANARCONFIG_SEPARATE image, we don't want that; so here are modifications of
+ code in the JPEG Library's "jdcolor.c" file, which simply copy Bytes to a
+ color plane specified by the current JPEG "scan".
+*/
+METHODDEF(void)
+ycc_rgb_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
+ register JSAMPARRAY out,register int nrows)
+ { typedef struct /* "jdcolor.c" color-space conversion state */
+ {
+
+ /* WARNING: This declaration is ugly and dangerous! It's supposed to be
+ private to the JPEG Library's "jdcolor.c" module, but we also
+ need it here. Since the library's copy might change without notice, be
+ sure to keep this one synchronized or the following code will break!
+ */
+ struct jpeg_color_deconverter pub; /* Public fields */
+ /* Private state for YCC->RGB conversion */
+ int *Cr_r_tab, /* ->Cr to R conversion table */
+ *Cb_b_tab; /* ->Cb to B conversion table */
+ INT32 *Cr_g_tab, /* ->Cr to G conversion table */
+ *Cb_g_tab; /* ->Cb to G conversion table */
+ } *my_cconvert_ptr;
+ my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
+ JSAMPARRAY irow0p = in[0] + row;
+ register JSAMPLE *range_limit = cinfo->sample_range_limit;
+ register JSAMPROW outp, Y;
+
+ switch (cinfo->output_scan_number - 1)
+ { JSAMPARRAY irow1p, irow2p;
+ register INT32 *table0, *table1;
+ SHIFT_TEMPS
+
+ case RGB_RED : irow2p = in[2] + row;
+ table0 = (INT32 *)cconvert->Cr_r_tab;
+ while (--nrows >= 0)
+ { register JSAMPROW Cr = *irow2p++;
+ register int i = cinfo->output_width;
+
+ Y = *irow0p++;
+ outp = *out++;
+ while (--i >= 0)
+ *outp++ = range_limit[*Y++ + table0[*Cr++]];
+ };
+ return;
+ case RGB_GREEN: irow1p = in[1] + row;
+ irow2p = in[2] + row;
+ table0 = cconvert->Cb_g_tab;
+ table1 = cconvert->Cr_g_tab;
+ while (--nrows >= 0)
+ { register JSAMPROW Cb = *irow1p++,
+ Cr = *irow2p++;
+ register int i = cinfo->output_width;
+
+ Y = *irow0p++;
+ outp = *out++;
+ while (--i >= 0)
+ *outp++ =
+ range_limit[ *Y++
+ + RIGHT_SHIFT(table0[*Cb++]+table1[*Cr++],16)
+ ];
+ };
+ return;
+ case RGB_BLUE : irow1p = in[1] + row;
+ table0 = (INT32 *)cconvert->Cb_b_tab;
+ while (--nrows >= 0)
+ { register JSAMPROW Cb = *irow1p++;
+ register int i = cinfo->output_width;
+
+ Y = *irow0p++;
+ outp = *out++;
+ while (--i >= 0)
+ *outp++ = range_limit[*Y++ + table0[*Cb++]];
+ }
+ }
+ }
+
+METHODDEF(void)
+null_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
+ register JSAMPARRAY out,register int nrows)
+ { register JSAMPARRAY irowp = in[cinfo->output_scan_number - 1] + row;
+
+ while (--nrows >= 0) _TIFFmemcpy(*out++,*irowp++,cinfo->output_width);
+ }
-#ifndef LIBJPEG_ENCAP_EXTERNAL
static int
-jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines)
-{
- return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_scanlines(cinfo,scanlines,max_lines),1));
-}
-#endif
+OJPEGSetupDecode(register TIFF *tif)
+ { static char module[]={"OJPEGSetupDecode"};
+ J_COLOR_SPACE jpeg_color_space, /* Color space of JPEG-compressed image */
+ out_color_space; /* Color space of decompressed image */
+ uint32 segment_width;
+ int status = 1; /* Assume success by default */
+ boolean downsampled_output=FALSE, /* <=> Want JPEG Library's "raw" image? */
+ is_JFIF; /* <=> JFIF image? */
+ register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ /* Verify miscellaneous parameters. This will need work if the TIFF Library
+ ever supports different depths for different components, or if the JPEG
+ Library ever supports run-time depth selection. Neither seems imminent.
+ */
+ if (td->td_bitspersample != sp->cinfo.d.data_precision)
+ {
+ TIFFError(module,bad_bps,td->td_bitspersample);
+ status = 0;
+ };
+
+ /* The TIFF Version 6.0 specification and IJG JPEG Library accept different
+ sets of color spaces, so verify that our image belongs to the common subset
+ and map its photometry code, then initialize to handle subsampling and
+ optional JPEG Library YCbCr <-> RGB color-space conversion.
+ */
+ switch (td->td_photometric)
+ {
+ case PHOTOMETRIC_YCBCR :
+
+ /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
+ TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
+ */
+ if ( ( td->td_ycbcrsubsampling[0] == 1
+ || td->td_ycbcrsubsampling[0] == 2
+ || td->td_ycbcrsubsampling[0] == 4
+ )
+ && ( td->td_ycbcrsubsampling[1] == 1
+ || td->td_ycbcrsubsampling[1] == 2
+ || td->td_ycbcrsubsampling[1] == 4
+ )
+ )
+ downsampled_output =
+ (
+ (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
+ | (sp->v_sampling = td->td_ycbcrsubsampling[1])
+ ) != 011;
+ else
+ {
+ TIFFError(module,bad_subsampling);
+ status = 0;
+ };
+ jpeg_color_space = JCS_YCbCr;
+ if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
+ {
+ downsampled_output = FALSE;
+ out_color_space = JCS_RGB;
+ break;
+ };
+ goto L2;
+ case PHOTOMETRIC_MINISBLACK:
+ jpeg_color_space = JCS_GRAYSCALE;
+ goto L1;
+ case PHOTOMETRIC_RGB :
+ jpeg_color_space = JCS_RGB;
+ goto L1;
+ case PHOTOMETRIC_SEPARATED :
+ jpeg_color_space = JCS_CMYK;
+ L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
+ L2: out_color_space = jpeg_color_space;
+ break;
+ default :
+ TIFFError(module,bad_photometry,td->td_photometric);
+ status = 0;
+ };
+ if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
+
+ /* Set parameters that are same for all strips/tiles. */
+
+ sp->cinfo.d.src = &sp->src;
+ sp->src.init_source = std_init_source;
+ sp->src.fill_input_buffer = std_fill_input_buffer;
+ sp->src.skip_input_data = std_skip_input_data;
+ sp->src.resync_to_restart = jpeg_resync_to_restart;
+ sp->src.term_source = std_term_source;
+
+ /* BOGOSITY ALERT! The Wang Imaging application for Microsoft Windows produces
+ images containing "JPEGInterchangeFormat[Length]" TIFF
+ records that resemble JFIF-in-TIFF encapsulations but, in fact, violate the
+ TIFF Version 6 specification in several ways; nevertheless, we try to handle
+ them gracefully because there are apparently a lot of them around. The
+ purported "JFIF" data stream in one of these files vaguely resembles a JPEG
+ "tables only" data stream, except that there's no trailing EOI marker. The
+ rest of the JPEG data stream lies in a discontiguous file region, identified
+ by the 0th Strip offset (which is *also* illegal!), where it begins with an
+ SOS marker and apparently continues to the end of the file. There is no
+ trailing EOI marker here, either.
+ */
+ is_JFIF = !sp->is_WANG && TIFFFieldSet(tif,FIELD_JPEGIFOFFSET);
-#ifndef LIBJPEG_ENCAP_EXTERNAL
-static int
-jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines)
-{
- return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_raw_data(cinfo,data,max_lines),1));
-}
-#endif
+ /* Initialize decompression parameters that won't be overridden by JPEG Library
+ defaults set during the "jpeg_read_header()" call, below.
+ */
+ segment_width = td->td_imagewidth;
+ if (isTiled(tif))
+ {
+ if (sp->is_WANG) /* we don't know how to handle it */
+ {
+ TIFFError(module,"Tiled Wang image not supported");
+ return 0;
+ };
+
+ /* BOGOSITY ALERT! "TIFFTileRowSize()" seems to work fine for modern JPEG-
+ in-TIFF encapsulations where the image width--like the
+ tile width--is a multiple of 8 or 16 pixels. But image widths and
+ heights are aren't restricted to 8- or 16-bit multiples, and we need
+ the exact Byte count of decompressed scan lines when we call the JPEG
+ Library. At least one old file ("zackthecat.tif") in the TIFF Library
+ test suite has widths and heights slightly less than the tile sizes, and
+ it apparently used the bogus computation below to determine the number
+ of Bytes per scan line (was this due to an old, broken version of
+ "TIFFhowmany()"?). Before we get here, "OJPEGSetupDecode()" verified
+ that our image uses 8-bit samples, so the following check appears to
+ return the correct answer in all known cases tested to date.
+ */
+ if (is_JFIF || (segment_width & 7) == 0)
+ sp->bytesperline = TIFFTileRowSize(tif); /* Normal case */
+ else
+ {
+ /* Was the file-encoder's segment-width calculation bogus? */
+ segment_width = (segment_width/sp->h_sampling + 1) * sp->h_sampling;
+ sp->bytesperline = segment_width * td->td_samplesperpixel;
+ }
+ }
+ else sp->bytesperline = TIFFVStripSize(tif,1);
+
+ /* BEWARE OF KLUDGE: If we have JPEG Interchange File Format (JFIF) image,
+ then we want to read "metadata" in the bit-stream's
+ header and validate it against corresponding information in TIFF records.
+ But if we have a *really old* JPEG file that's not JFIF, then we simply
+ assign TIFF-record values to JPEG Library variables without checking.
+ */
+ if (is_JFIF) /* JFIF image */
+ { unsigned char *end_of_data;
+ int subsampling_factors;
+ register unsigned char *p;
+ register int i;
+
+ /* WARNING: Although the image file contains a JFIF bit stream, it might
+ also contain some old TIFF records causing "OJPEGVSetField()"
+ to have allocated quantization or Huffman decoding tables. But when the
+ JPEG Library reads and parses the JFIF header below, it reallocate these
+ tables anew without checking for "dangling" pointers, thereby causing a
+ memory "leak". We have enough information to potentially deallocate the
+ old tables here, but unfortunately JPEG Library Version 6B uses a "pool"
+ allocator for small objects, with no deallocation procedure; instead, it
+ reclaims a whole pool when an image is closed/destroyed, so well-behaved
+ TIFF client applications (i.e., those which close their JPEG images as
+ soon as they're no longer needed) will waste memory for a short time but
+ recover it eventually. But ill-behaved TIFF clients (i.e., those which
+ keep many JPEG images open gratuitously) can exhaust memory prematurely.
+ If the JPEG Library ever implements a deallocation procedure, insert
+ this clean-up code:
+ */
+# ifdef someday
+ if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) /* free quant. tables */
+ { register int i = 0;
+
+ do
+ { register JQUANT_TBL *q;
+
+ if (q = sp->cinfo.d.quant_tbl_ptrs[i])
+ {
+ jpeg_free_small(&sp->cinfo.comm,q,sizeof *q);
+ sp->cinfo.d.quant_tbl_ptrs[i] = 0;
+ }
+ }
+ while (++i < NUM_QUANT_TBLS);
+ };
+ if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) /* free Huffman tables */
+ { register int i = 0;
+
+ do
+ { register JHUFF_TBL *h;
+
+ if (h = sp->cinfo.d.dc_huff_tbl_ptrs[i])
+ {
+ jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
+ sp->cinfo.d.dc_huff_tbl_ptrs[i] = 0;
+ };
+ if (h = sp->cinfo.d.ac_huff_tbl_ptrs[i])
+ {
+ jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
+ sp->cinfo.d.ac_huff_tbl_ptrs[i] = 0;
+ }
+ }
+ while (++i < NUM_HUFF_TBLS);
+ };
+# endif /* someday */
+
+ /* Since we might someday wish to try rewriting "old format" JPEG-in-TIFF
+ encapsulations in "new format" files, try to synthesize the value of a
+ modern "JPEGTables" TIFF record by scanning the JPEG data from just past
+ the "Start of Information" (SOI) marker until something other than a
+ legitimate "table" marker is found, as defined in ISO IS 10918-1
+ Appending B.2.4; namely:
+
+ -- Define Quantization Table (DQT)
+ -- Define Huffman Table (DHT)
+ -- Define Arithmetic Coding table (DAC)
+ -- Define Restart Interval (DRI)
+ -- Comment (COM)
+ -- Application data (APPn)
+
+ For convenience, we also accept "Expansion" (EXP) markers, although they
+ are apparently not a part of normal "table" data.
+ */
+ sp->jpegtables = p = (unsigned char *)sp->src.next_input_byte;
+ end_of_data = p + sp->src.bytes_in_buffer;
+ p += 2;
+ while (p < end_of_data && p[0] == 0xFF)
+ switch (p[1])
+ {
+ default : goto L;
+ case 0xC0: /* SOF0 */
+ case 0xC1: /* SOF1 */
+ case 0xC2: /* SOF2 */
+ case 0xC3: /* SOF3 */
+ case 0xC4: /* DHT */
+ case 0xC5: /* SOF5 */
+ case 0xC6: /* SOF6 */
+ case 0xC7: /* SOF7 */
+ case 0xC9: /* SOF9 */
+ case 0xCA: /* SOF10 */
+ case 0xCB: /* SOF11 */
+ case 0xCC: /* DAC */
+ case 0xCD: /* SOF13 */
+ case 0xCE: /* SOF14 */
+ case 0xCF: /* SOF15 */
+ case 0xDB: /* DQT */
+ case 0xDD: /* DRI */
+ case 0xDF: /* EXP */
+ case 0xE0: /* APP0 */
+ case 0xE1: /* APP1 */
+ case 0xE2: /* APP2 */
+ case 0xE3: /* APP3 */
+ case 0xE4: /* APP4 */
+ case 0xE5: /* APP5 */
+ case 0xE6: /* APP6 */
+ case 0xE7: /* APP7 */
+ case 0xE8: /* APP8 */
+ case 0xE9: /* APP9 */
+ case 0xEA: /* APP10 */
+ case 0xEB: /* APP11 */
+ case 0xEC: /* APP12 */
+ case 0xED: /* APP13 */
+ case 0xEE: /* APP14 */
+ case 0xEF: /* APP15 */
+ case 0xFE: /* COM */
+ p += (p[2] << 8 | p[3]) + 2;
+ };
+ L: if (p - (unsigned char *)sp->jpegtables > 2) /* fake "JPEGTables" */
+ {
+
+ /* In case our client application asks, pretend that this image file
+ contains a modern "JPEGTables" TIFF record by copying to a buffer
+ the initial part of the JFIF bit-stream that we just scanned, from
+ the SOI marker through the "metadata" tables, then append an EOI
+ marker and flag the "JPEGTables" TIFF record as "present".
+ */
+ sp->jpegtables_length = p - (unsigned char*)sp->jpegtables + 2;
+ p = sp->jpegtables;
+ if (!(sp->jpegtables = _TIFFmalloc(sp->jpegtables_length)))
+ {
+ TIFFError(module,no_jtable_space);
+ return 0;
+ };
+ _TIFFmemcpy(sp->jpegtables,p,sp->jpegtables_length-2);
+ p = (unsigned char *)sp->jpegtables + sp->jpegtables_length;
+ p[-2] = 0xFF; p[-1] = JPEG_EOI; /* Append EOI marker */
+ TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
+ tif->tif_flags |= TIFF_DIRTYDIRECT;
+ }
+ else sp->jpegtables = 0; /* Don't simulate "JPEGTables" */
+ if ( CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE))
+ != JPEG_HEADER_OK
+ ) return 0;
+ if ( sp->cinfo.d.image_width != segment_width
+ || sp->cinfo.d.image_height != td->td_imagelength
+ )
+ {
+ TIFFError(module,"Improper JPEG strip/tile size");
+ return 0;
+ };
+ if (sp->cinfo.d.num_components != td->td_samplesperpixel)
+ {
+ TIFFError(module,"Improper JPEG component count");
+ return 0;
+ };
+ if (sp->cinfo.d.data_precision != td->td_bitspersample)
+ {
+ TIFFError(module,"Improper JPEG data precision");
+ return 0;
+ };
+
+ /* Check that JPEG image components all have the same subsampling factors
+ declared (or defaulted) in the TIFF file, since TIFF Version 6.0 is more
+ restrictive than JPEG: Only the 0th component may have horizontal and
+ vertical subsampling factors other than <1,1>.
+ */
+ subsampling_factors = sp->h_sampling << 3 | sp->v_sampling;
+ i = 0;
+ do
+ {
+ if ( ( sp->cinfo.d.comp_info[i].h_samp_factor << 3
+ | sp->cinfo.d.comp_info[i].v_samp_factor
+ )
+ != subsampling_factors
+ )
+ {
+ TIFFError(module,"Improper JPEG subsampling factors");
+ return 0;
+ };
+ subsampling_factors = 011; /* Required for image components > 0 */
+ }
+ while (++i < sp->cinfo.d.num_components);
+ }
+ else /* not JFIF image */
+ { int (*save)(j_decompress_ptr cinfo) = sp->cinfo.d.marker->read_markers;
+ register int i;
+
+ /* We're not assuming that this file's JPEG bit stream has any header
+ "metadata", so fool the JPEG Library into thinking that we read a
+ "Start of Input" (SOI) marker and a "Start of Frame" (SOFx) marker, then
+ force it to read a simulated "Start of Scan" (SOS) marker when we call
+ "jpeg_read_header()" below. This should cause the JPEG Library to
+ establish reasonable defaults.
+ */
+ sp->cinfo.d.marker->saw_SOI = /* Pretend we saw SOI marker */
+ sp->cinfo.d.marker->saw_SOF = TRUE; /* Pretend we saw SOF marker */
+ sp->cinfo.d.marker->read_markers =
+ sp->is_WANG ? suspend : fake_SOS_marker;
+ sp->cinfo.d.global_state = DSTATE_INHEADER;
+ sp->cinfo.d.Se = DCTSIZE2-1; /* Suppress JPEG Library warning */
+ sp->cinfo.d.image_width = segment_width;
+ sp->cinfo.d.image_height = td->td_imagelength;
+
+ /* The following color-space initialization, including the complicated
+ "switch"-statement below, essentially duplicates the logic used by the
+ JPEG Library's "jpeg_init_colorspace()" subroutine during compression.
+ */
+ sp->cinfo.d.num_components = td->td_samplesperpixel;
+ sp->cinfo.d.comp_info = (jpeg_component_info *)
+ (*sp->cinfo.d.mem->alloc_small)
+ ( &sp->cinfo.comm
+ , JPOOL_IMAGE
+ , sp->cinfo.d.num_components * sizeof *sp->cinfo.d.comp_info
+ );
+ i = 0;
+ do
+ {
+ sp->cinfo.d.comp_info[i].component_index = i;
+ sp->cinfo.d.comp_info[i].component_needed = TRUE;
+ sp->cinfo.d.cur_comp_info[i] = &sp->cinfo.d.comp_info[i];
+ }
+ while (++i < sp->cinfo.d.num_components);
+ switch (jpeg_color_space)
+ {
+ case JCS_UNKNOWN :
+ i = 0;
+ do
+ {
+ sp->cinfo.d.comp_info[i].component_id = i;
+ sp->cinfo.d.comp_info[i].h_samp_factor =
+ sp->cinfo.d.comp_info[i].v_samp_factor = 1;
+ }
+ while (++i < sp->cinfo.d.num_components);
+ break;
+ case JCS_GRAYSCALE:
+ sp->cinfo.d.comp_info[0].component_id =
+ sp->cinfo.d.comp_info[0].h_samp_factor =
+ sp->cinfo.d.comp_info[0].v_samp_factor = 1;
+ break;
+ case JCS_RGB :
+ sp->cinfo.d.comp_info[0].component_id = 'R';
+ sp->cinfo.d.comp_info[1].component_id = 'G';
+ sp->cinfo.d.comp_info[2].component_id = 'B';
+ i = 0;
+ do sp->cinfo.d.comp_info[i].h_samp_factor =
+ sp->cinfo.d.comp_info[i].v_samp_factor = 1;
+ while (++i < sp->cinfo.d.num_components);
+ break;
+ case JCS_CMYK :
+ sp->cinfo.d.comp_info[0].component_id = 'C';
+ sp->cinfo.d.comp_info[1].component_id = 'M';
+ sp->cinfo.d.comp_info[2].component_id = 'Y';
+ sp->cinfo.d.comp_info[3].component_id = 'K';
+ i = 0;
+ do sp->cinfo.d.comp_info[i].h_samp_factor =
+ sp->cinfo.d.comp_info[i].v_samp_factor = 1;
+ while (++i < sp->cinfo.d.num_components);
+ break;
+ case JCS_YCbCr :
+ i = 0;
+ do
+ {
+ sp->cinfo.d.comp_info[i].component_id = i+1;
+ sp->cinfo.d.comp_info[i].h_samp_factor =
+ sp->cinfo.d.comp_info[i].v_samp_factor = 1;
+ sp->cinfo.d.comp_info[i].quant_tbl_no =
+ sp->cinfo.d.comp_info[i].dc_tbl_no =
+ sp->cinfo.d.comp_info[i].ac_tbl_no = i > 0;
+ }
+ while (++i < sp->cinfo.d.num_components);
+ sp->cinfo.d.comp_info[0].h_samp_factor = sp->h_sampling;
+ sp->cinfo.d.comp_info[0].v_samp_factor = sp->v_sampling;
+ };
+ sp->cinfo.d.comps_in_scan = td->td_planarconfig == PLANARCONFIG_CONTIG
+ ? sp->cinfo.d.num_components
+ : 1;
+ i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,!sp->is_WANG));
+ sp->cinfo.d.marker->read_markers = save; /* Restore input method */
+ if (sp->is_WANG) /* produced by Wang Imaging on Microsoft Windows */
+ {
+ if (i != JPEG_SUSPENDED) return 0;
+
+ /* BOGOSITY ALERT! Files prooduced by the Wang Imaging application for
+ Microsoft Windows are a special--and, technically
+ illegal--case. A JPEG SOS marker and rest of the data stream should
+ be located at the end of the file, in a position identified by the
+ 0th Strip offset.
+ */
+ i = td->td_nstrips - 1;
+ sp->src.next_input_byte = tif->tif_base + td->td_stripoffset[0];
+ sp->src.bytes_in_buffer = td->td_stripoffset[i] -
+ td->td_stripoffset[0] + td->td_stripbytecount[i];
+ i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE));
+ };
+ if (i != JPEG_HEADER_OK) return 0;
+ };
+
+ /* Some of our initialization must wait until the JPEG Library is initialized
+ above, in order to override its defaults.
+ */
+ if ( (sp->cinfo.d.raw_data_out = downsampled_output)
+ && !alloc_downsampled_buffers(tif,sp->cinfo.d.comp_info,
+ sp->cinfo.d.num_components)
+ ) return 0;
+ sp->cinfo.d.jpeg_color_space = jpeg_color_space;
+ sp->cinfo.d.out_color_space = out_color_space;
+ sp->cinfo.d.dither_mode = JDITHER_NONE; /* Reduce image "noise" */
+ sp->cinfo.d.two_pass_quantize = FALSE;
+
+ /* If the image consists of separate, discontiguous TIFF "samples" (= color
+ planes, hopefully = JPEG "scans"), then we must use the JPEG Library's
+ "buffered image" mode to decompress the entire image into temporary buffers,
+ because the JPEG Library must parse the entire JPEG bit-stream in order to
+ be satsified that it has a complete set of color components for each pixel,
+ but the TIFF Library must allow our client to extract 1 component at a time.
+ Initializing the JPEG Library's "buffered image" mode is tricky: First, we
+ start its decompressor, then we tell the decompressor to "consume" (i.e.,
+ buffer) the entire bit-stream.
+
+ WARNING: Disabling "fancy" up-sampling seems to slightly reduce "noise" for
+ certain old Wang Imaging files, but it absolutely *must* be
+ enabled if the image has separate color planes, since in that case, the JPEG
+ Library doesn't use an "sp->cinfo.d.cconvert" structure (so de-referencing
+ this pointer below will cause a fatal crash) but writing our own code to up-
+ sample separate color planes is too much work for right now. Maybe someday?
+ */
+ sp->cinfo.d.do_fancy_upsampling = /* Always let this default (to TRUE)? */
+ sp->cinfo.d.buffered_image = td->td_planarconfig == PLANARCONFIG_SEPARATE;
+ if (!CALLJPEG(sp,0,jpeg_start_decompress(&sp->cinfo.d))) return 0;
+ if (sp->cinfo.d.buffered_image) /* separate color planes */
+ {
+ if (sp->cinfo.d.raw_data_out)
+ tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
+ OJPEGDecodeRawSeparate;
+ else
+ {
+ tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
+ OJPEGDecode;
+
+ /* In JPEG Library Version 6B, color-space conversion isn't implemented
+ for separate color planes, so we must do it ourself if our TIFF
+ client doesn't want to:
+ */
+ sp->cinfo.d.cconvert->color_convert =
+ sp->cinfo.d.jpeg_color_space == sp->cinfo.d.out_color_space
+ ? null_convert : ycc_rgb_convert;
+ };
+ L3: switch (CALLJPEG(sp,0,jpeg_consume_input(&sp->cinfo.d)))
+ {
+ default : goto L3;
+
+ /* If no JPEG "End of Information" (EOI) marker is found when bit-
+ stream parsing ends, check whether we have enough data to proceed
+ before reporting an error.
+ */
+ case JPEG_SUSPENDED : if ( sp->cinfo.d.input_scan_number
+ *sp->cinfo.d.image_height
+ + sp->cinfo.d.input_iMCU_row
+ *sp->cinfo.d.max_v_samp_factor
+# ifdef D_LOSSLESS_SUPPORTED
+ *sp->cinfo.d.data_units_in_MCU
+ *sp->cinfo.d.min_codec_data_unit
+# else
+ *sp->cinfo.d.blocks_in_MCU
+ *DCTSIZE
+# endif
+ < td->td_samplesperpixel
+ *sp->cinfo.d.image_height
+ )
+ {
+ TIFFError(tif->tif_name,
+ "Premature end of JPEG bit-stream");
+ return 0;
+ }
+ case JPEG_REACHED_EOI: ;
+ }
+ }
+ else /* pixel-interleaved color planes */
+ tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
+ downsampled_output ? OJPEGDecodeRawContig : OJPEGDecode;
+ return 1;
+# undef td
+ }
-#ifndef LIBJPEG_ENCAP_EXTERNAL
-static void
-jpeg_encap_unwind(TIFF* tif)
-{
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- LONGJMP(sp->exit_jmpbuf,1);
-}
-#endif
+static int
+OJPEGPreDecode(register TIFF *tif,tsample_t s)
+ { register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ /* If we are about to read the first row of an image plane (hopefully, these
+ are coincident with JPEG "scans"!), reset the JPEG Library's decompressor
+ appropriately. Otherwise, let the decompressor run "as is" and return a
+ "success" status without further ado.
+ */
+ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
+ % td->td_stripsperimage
+ == 0
+ )
+ {
+ if ( sp->cinfo.d.buffered_image
+ && !CALLJPEG(sp,0,jpeg_start_output(&sp->cinfo.d,s+1))
+ ) return 0;
+ sp->cinfo.d.output_scanline = 0;
+
+ /* Mark subsampling buffers "empty". */
+
+# ifdef D_LOSSLESS_SUPPORTED
+ sp->scancount = sp->cinfo.d.min_codec_data_unit;
+# else
+ sp->scancount = DCTSIZE;
+# endif
+ };
+ return 1;
+# undef td
+ }
+
+/*ARGSUSED*/ static void
+OJPEGPostDecode(register TIFF *tif,tidata_t buf,tsize_t cc)
+ { register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ /* The JPEG Library decompressor has reached the end of a strip/tile. If this
+ is the end of a TIFF image "sample" (= JPEG "scan") in a file with separate
+ components (color planes), then end the "scan". If it ends the image's last
+ sample/scan, then also stop the JPEG Library's decompressor.
+ */
+ if (sp->cinfo.d.output_scanline >= sp->cinfo.d.output_height)
+ {
+ if (sp->cinfo.d.buffered_image)
+ CALLJPEG(sp,-1,jpeg_finish_output(&sp->cinfo.d)); /* End JPEG scan */
+ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
+ >= td->td_nstrips-1
+ ) CALLJPEG(sp,0,jpeg_finish_decompress(&sp->cinfo.d));
+ }
+# undef td
+ }
-static void
-OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo)
+static int
+OJPEGVSetField(register TIFF *tif,ttag_t tag,va_list ap)
{
- char buffer[JMSG_LENGTH_MAX];
- (*cinfo->err->format_message)(cinfo,buffer);
- TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg", "%s", buffer);
-}
+ uint32 v32;
+ register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+ toff_t tiffoff=0;
+ uint32 bufoff=0;
+ uint32 code_count=0;
+ int i2=0;
+ int k2=0;
+
+ switch (tag)
+ {
+ default : return
+ (*sp->vsetparent)(tif,tag,ap);
+
+ /* BEWARE OF KLUDGE: Some old-format JPEG-in-TIFF files, including those
+ produced by the Wang Imaging application for Micro-
+ soft Windows, illegally omit a "ReferenceBlackWhite" TIFF tag, even
+ though the TIFF specification's default is intended for the RGB color
+ space and is inappropriate for the YCbCr color space ordinarily used for
+ JPEG images. Since many TIFF client applications request the value of
+ this tag immediately after a TIFF image directory is parsed, and before
+ any other code in this module receives control, we are forced to fix
+ this problem very early in image-file processing. Fortunately, legal
+ TIFF files are supposed to store their tags in numeric order, so a
+ mandatory "PhotometricInterpretation" tag should always appear before
+ an optional "ReferenceBlackWhite" tag. Hence, we slyly peek ahead when
+ we discover the desired photometry, by installing modified black and
+ white reference levels.
+ */
+ case TIFFTAG_PHOTOMETRIC :
+ if ( (v32 = (*sp->vsetparent)(tif,tag,ap))
+ && td->td_photometric == PHOTOMETRIC_YCBCR
+ )
+ {
+ float *ref;
+ if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE, &ref)) {
+ float refbw[6];
+ long top = 1L << td->td_bitspersample;
+ refbw[0] = 0;
+ refbw[1] = (float)(top-1L);
+ refbw[2] = (float)(top>>1);
+ refbw[3] = refbw[1];
+ refbw[4] = refbw[2];
+ refbw[5] = refbw[1];
+ TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE, refbw);
+ }
+ }
+ return v32;
+
+ /* BEWARE OF KLUDGE: According to Charles Auer <Bumble731@msn.com>, if our
+ input is a multi-image (multi-directory) JPEG-in-TIFF
+ file is produced by the Wang Imaging application on Microsoft Windows,
+ for some reason the first directory excludes the vendor-specific "WANG
+ PageControl" tag (32934) that we check below, so the only other way to
+ identify these directories is apparently to look for a software-
+ identification tag with the substring, "Wang Labs". Single-image files
+ can apparently pass both tests, which causes no harm here, but what a
+ mess this is!
+ */
+ case TIFFTAG_SOFTWARE :
+ {
+ char *software;
+
+ v32 = (*sp->vsetparent)(tif,tag,ap);
+ if( TIFFGetField( tif, TIFFTAG_SOFTWARE, &software )
+ && strstr( software, "Wang Labs" ) )
+ sp->is_WANG = 1;
+ return v32;
+ }
+
+ case TIFFTAG_JPEGPROC :
+ case TIFFTAG_JPEGIFOFFSET :
+ case TIFFTAG_JPEGIFBYTECOUNT :
+ case TIFFTAG_JPEGRESTARTINTERVAL :
+ case TIFFTAG_JPEGLOSSLESSPREDICTORS:
+ case TIFFTAG_JPEGPOINTTRANSFORM :
+ case TIFFTAG_JPEGQTABLES :
+ case TIFFTAG_JPEGDCTABLES :
+ case TIFFTAG_JPEGACTABLES :
+ case TIFFTAG_WANG_PAGECONTROL :
+ case TIFFTAG_JPEGCOLORMODE : ;
+ };
+ v32 = va_arg(ap,uint32); /* No. of values in this TIFF record */
+
+ /* This switch statement is added for OJPEGVSetField */
+ if(v32 !=0){
+ switch(tag){
+ case TIFFTAG_JPEGPROC:
+ sp->jpegproc=v32;
+ break;
+ case TIFFTAG_JPEGIFOFFSET:
+ sp->jpegifoffset=v32;
+ break;
+ case TIFFTAG_JPEGIFBYTECOUNT:
+ sp->jpegifbytecount=v32;
+ break;
+ case TIFFTAG_JPEGRESTARTINTERVAL:
+ sp->jpegrestartinterval=v32;
+ break;
+ case TIFFTAG_JPEGLOSSLESSPREDICTORS:
+ sp->jpeglosslesspredictors_length=v32;
+ break;
+ case TIFFTAG_JPEGPOINTTRANSFORM:
+ sp->jpegpointtransform_length=v32;
+ break;
+ case TIFFTAG_JPEGQTABLES:
+ sp->jpegqtables_length=v32;
+ break;
+ case TIFFTAG_JPEGACTABLES:
+ sp->jpegactables_length=v32;
+ break;
+ case TIFFTAG_JPEGDCTABLES:
+ sp->jpegdctables_length=v32;
+ break;
+ default:
+ break;
+ }
+ }
+
+ /* BEWARE: The following actions apply only if we are reading a "source" TIFF
+ image to be decompressed for a client application program. If we
+ ever enhance this file's CODEC to write "destination" JPEG-in-TIFF images,
+ we'll need an "if"- and another "switch"-statement below, because we'll
+ probably want to store these records' values in some different places. Most
+ of these need not be parsed here in order to decode JPEG bit stream, so we
+ set boolean flags to note that they have been seen, but we otherwise ignore
+ them.
+ */
+ switch (tag)
+ { JHUFF_TBL **h;
+
+ /* Validate the JPEG-process code. */
+
+ case TIFFTAG_JPEGPROC :
+ switch (v32)
+ {
+ default : TIFFError(tif->tif_name,
+ "Unknown JPEG process");
+ return 0;
+# ifdef C_LOSSLESS_SUPPORTED
+
+ /* Image uses (lossy) baseline sequential coding. */
+
+ case JPEGPROC_BASELINE: sp->cinfo.d.process = JPROC_SEQUENTIAL;
+ sp->cinfo.d.data_unit = DCTSIZE;
+ break;
+
+ /* Image uses (lossless) Huffman coding. */
+
+ case JPEGPROC_LOSSLESS: sp->cinfo.d.process = JPROC_LOSSLESS;
+ sp->cinfo.d.data_unit = 1;
+# else /* not C_LOSSLESS_SUPPORTED */
+ case JPEGPROC_LOSSLESS: TIFFError(JPEGLib_name,
+ "Does not support lossless Huffman coding");
+ return 0;
+ case JPEGPROC_BASELINE: ;
+# endif /* C_LOSSLESS_SUPPORTED */
+ };
+ break;
+
+ /* The TIFF Version 6.0 specification says that if the value of a TIFF
+ "JPEGInterchangeFormat" record is 0, then we are to behave as if this
+ record were absent; i.e., the data does *not* represent a JPEG Inter-
+ change Format File (JFIF), so don't even set the boolean "I've been
+ here" flag below. Otherwise, the field's value represents the file
+ offset of the JPEG SOI marker.
+ */
+ case TIFFTAG_JPEGIFOFFSET :
+ if (v32)
+ {
+ sp->src.next_input_byte = tif->tif_base + v32;
+ break;
+ };
+ return 1;
+ case TIFFTAG_JPEGIFBYTECOUNT :
+ sp->src.bytes_in_buffer = v32;
+ break;
+
+ /* The TIFF Version 6.0 specification says that if the JPEG "Restart"
+ marker interval is 0, then the data has no "Restart" markers; i.e., we
+ must behave as if this TIFF record were absent. So, don't even set the
+ boolean "I've been here" flag below.
+ */
+ /*
+ * Instead, set the field bit so TIFFGetField can get whether or not
+ * it was set.
+ */
+ case TIFFTAG_JPEGRESTARTINTERVAL :
+ if (v32)
+ sp->cinfo.d.restart_interval = v32;
+ break;
+ /* The TIFF Version 6.0 specification says that this tag is supposed to be
+ a vector containing a value for each image component, but for lossless
+ Huffman coding (the only JPEG process defined by the specification for
+ which this tag should be needed), ISO IS 10918-1 uses only a single
+ value, equivalent to the "Ss" field in a JPEG bit-stream's "Start of
+ Scan" (SOS) marker. So, we extract the first vector element and ignore
+ the rest. (I hope this is correct!)
+ */
+ case TIFFTAG_JPEGLOSSLESSPREDICTORS:
+ if (v32)
+ {
+ sp->cinfo.d.Ss = *va_arg(ap,uint16 *);
+ sp->jpeglosslesspredictors =
+ _TIFFmalloc(sp->jpeglosslesspredictors_length
+ * sizeof(uint16));
+ if(sp->jpeglosslesspredictors==NULL){return(0);}
+ for(i2=0;i2<sp->jpeglosslesspredictors_length;i2++){
+ ((uint16*)sp->jpeglosslesspredictors)[i2] =
+ ((uint16*)sp->cinfo.d.Ss)[i2];
+ }
+ sp->jpeglosslesspredictors_length*=sizeof(uint16);
+ break;
+ };
+ return v32;
+
+ /* The TIFF Version 6.0 specification says that this tag is supposed to be
+ a vector containing a value for each image component, but for lossless
+ Huffman coding (the only JPEG process defined by the specification for
+ which this tag should be needed), ISO IS 10918-1 uses only a single
+ value, equivalent to the "Al" field in a JPEG bit-stream's "Start of
+ Scan" (SOS) marker. So, we extract the first vector element and ignore
+ the rest. (I hope this is correct!)
+ */
+ case TIFFTAG_JPEGPOINTTRANSFORM :
+ if (v32)
+ {
+ sp->cinfo.d.Al = *va_arg(ap,uint16 *);
+ sp->jpegpointtransform =
+ _TIFFmalloc(sp->jpegpointtransform_length*sizeof(uint16));
+ if(sp->jpegpointtransform==NULL){return(0);}
+ for(i2=0;i2<sp->jpegpointtransform_length;i2++) {
+ ((uint16*)sp->jpegpointtransform)[i2] =
+ ((uint16*)sp->cinfo.d.Al)[i2];
+ }
+ sp->jpegpointtransform_length*=sizeof(uint16);
+ break;
+ }
+ return v32;
+
+ /* We have a vector of offsets to quantization tables, so load 'em! */
+
+ case TIFFTAG_JPEGQTABLES :
+ if (v32)
+ { uint32 *v;
+ int i;
+ if (v32 > NUM_QUANT_TBLS)
+ {
+ TIFFError(tif->tif_name,"Too many quantization tables");
+ return 0;
+ };
+ i = 0;
+ v = va_arg(ap,uint32 *);
+ sp->jpegqtables=_TIFFmalloc(64*sp->jpegqtables_length);
+ if(sp->jpegqtables==NULL){return(0);}
+ tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
+ bufoff=0;
+ for(i2=0;i2<sp->jpegqtables_length;i2++){
+ TIFFSeekFile(tif, v[i2], SEEK_SET);
+ TIFFReadFile(tif, &(((unsigned char*)(sp->jpegqtables))[bufoff]),
+ 64);
+ bufoff+=64;
+ }
+ sp->jpegqtables_length=bufoff;
+ TIFFSeekFile(tif, tiffoff, SEEK_SET);
+
+ do /* read quantization table */
+ { register UINT8 *from = tif->tif_base + *v++;
+ register UINT16 *to;
+ register int j = DCTSIZE2;
+
+ if (!( sp->cinfo.d.quant_tbl_ptrs[i]
+ = CALLJPEG(sp,0,jpeg_alloc_quant_table(&sp->cinfo.comm))
+ )
+ )
+ {
+ TIFFError(JPEGLib_name,"No space for quantization table");
+ return 0;
+ };
+ to = sp->cinfo.d.quant_tbl_ptrs[i]->quantval;
+ do *to++ = *from++; while (--j > 0);
+ }
+ while (++i < v32);
+ sp->jpegtablesmode |= JPEGTABLESMODE_QUANT;
+ };
+ break;
+
+ /* We have a vector of offsets to DC Huffman tables, so load 'em! */
+
+ case TIFFTAG_JPEGDCTABLES :
+ h = sp->cinfo.d.dc_huff_tbl_ptrs;
+ goto L;
+
+ /* We have a vector of offsets to AC Huffman tables, so load 'em! */
+
+ case TIFFTAG_JPEGACTABLES :
+ h = sp->cinfo.d.ac_huff_tbl_ptrs;
+ L: if (v32)
+ { uint32 *v;
+ int i;
+ if (v32 > NUM_HUFF_TBLS)
+ {
+ TIFFError(tif->tif_name,"Too many Huffman tables");
+ return 0;
+ };
+ v = va_arg(ap,uint32 *);
+ if(tag == TIFFTAG_JPEGDCTABLES) {
+ sp->jpegdctables=_TIFFmalloc(272*sp->jpegdctables_length);
+ if(sp->jpegdctables==NULL){return(0);}
+ tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
+ bufoff=0;
+ code_count=0;
+ for(i2=0;i2<sp->jpegdctables_length;i2++){
+ TIFFSeekFile(tif, v[i2], SEEK_SET);
+ TIFFReadFile(tif,
+ &(((unsigned char*)(sp->jpegdctables))[bufoff]),
+ 16);
+ code_count=0;
+ for(k2=0;k2<16;k2++){
+ code_count+=((unsigned char*)(sp->jpegdctables))[k2+bufoff];
+ }
+ TIFFReadFile(tif,
+ &(((unsigned char*)(sp->jpegdctables))[bufoff+16]),
+ code_count);
+ bufoff+=16;
+ bufoff+=code_count;
+ }
+ sp->jpegdctables_length=bufoff;
+ TIFFSeekFile(tif, tiffoff, SEEK_SET);
+ }
+ if(tag==TIFFTAG_JPEGACTABLES){
+ sp->jpegactables=_TIFFmalloc(272*sp->jpegactables_length);
+ if(sp->jpegactables==NULL){return(0);}
+ tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
+ bufoff=0;
+ code_count=0;
+ for(i2=0;i2<sp->jpegactables_length;i2++){
+ TIFFSeekFile(tif, v[i2], SEEK_SET);
+ TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff]), 16);
+ code_count=0;
+ for(k2=0;k2<16;k2++){
+ code_count+=((unsigned char*)(sp->jpegactables))[k2+bufoff];
+ }
+ TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff+16]), code_count);
+ bufoff+=16;
+ bufoff+=code_count;
+ }
+ sp->jpegactables_length=bufoff;
+ TIFFSeekFile(tif, tiffoff, SEEK_SET);
+ }
+ i = 0;
+ do /* copy each Huffman table */
+ { int size = 0;
+ register UINT8 *from = tif->tif_base + *v++, *to;
+ register int j = sizeof (*h)->bits;
+
+ /* WARNING: This code relies on the fact that an image file not
+ "memory mapped" was read entirely into a single
+ buffer by "TIFFInitOJPEG()", so we can do a fast memory-to-
+ memory copy here. Each table consists of 16 Bytes, which are
+ suffixed to a 0 Byte when copied, followed by a variable
+ number of Bytes whose length is the sum of the first 16.
+ */
+ if (!( *h
+ = CALLJPEG(sp,0,jpeg_alloc_huff_table(&sp->cinfo.comm))
+ )
+ )
+ {
+ TIFFError(JPEGLib_name,"No space for Huffman table");
+ return 0;
+ };
+ to = (*h++)->bits;
+ *to++ = 0;
+ while (--j > 0) size += *to++ = *from++; /* Copy 16 Bytes */
+ if (size > sizeof (*h)->huffval/sizeof *(*h)->huffval)
+ {
+ TIFFError(tif->tif_name,"Huffman table too big");
+ return 0;
+ };
+ if ((j = size) > 0) do *to++ = *from++; while (--j > 0);
+ while (++size <= sizeof (*h)->huffval/sizeof *(*h)->huffval)
+ *to++ = 0; /* Zero the rest of the table for cleanliness */
+ }
+ while (++i < v32);
+ sp->jpegtablesmode |= JPEGTABLESMODE_HUFF;
+ };
+ break;
+
+ /* The following vendor-specific TIFF tag occurs in (highly illegal) files
+ produced by the Wang Imaging application for Microsoft Windows. These
+ can apparently have several "pages", in which case this tag specifies
+ the offset of a "page control" structure, which we don't currently know
+ how to handle. 0 indicates a 1-page image with no "page control", which
+ we make a feeble effort to handle.
+ */
+ case TIFFTAG_WANG_PAGECONTROL :
+ if (v32 == 0) v32 = -1;
+ sp->is_WANG = v32;
+ tag = TIFFTAG_JPEGPROC+FIELD_WANG_PAGECONTROL-FIELD_JPEGPROC;
+ break;
+
+ /* This pseudo tag indicates whether our caller is expected to do YCbCr <->
+ RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
+ ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
+ */
+ case TIFFTAG_JPEGCOLORMODE :
+ sp->jpegcolormode = v32;
+
+ /* Mark the image to indicate whether returned data is up-sampled, so
+ that "TIFF{Strip,Tile}Size()" reflect the true amount of data present.
+ */
+ v32 = tif->tif_flags; /* Save flags temporarily */
+ tif->tif_flags &= ~TIFF_UPSAMPLED;
+ if ( td->td_photometric == PHOTOMETRIC_YCBCR
+ && (td->td_ycbcrsubsampling[0]<<3 | td->td_ycbcrsubsampling[1])
+ != 011
+ && sp->jpegcolormode == JPEGCOLORMODE_RGB
+ ) tif->tif_flags |= TIFF_UPSAMPLED;
+
+ /* If the up-sampling state changed, re-calculate tile size. */
+
+ if ((tif->tif_flags ^ v32) & TIFF_UPSAMPLED)
+ {
+ tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
+ tif->tif_flags |= TIFF_DIRTYDIRECT;
+ };
+ return 1;
+ };
+ TIFFSetFieldBit(tif,tag-TIFFTAG_JPEGPROC+FIELD_JPEGPROC);
+ return 1;
+# undef td
+ }
-static void
-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);
- jpeg_encap_unwind((TIFF*)(cinfo->client_data));
-}
+static int
+OJPEGVGetField(register TIFF *tif,ttag_t tag,va_list ap)
+ { register OJPEGState *sp = OJState(tif);
+
+ switch (tag)
+ {
+
+ /* If this file has managed to synthesize a set of consolidated "metadata"
+ tables for the current (post-TIFF Version 6.0 specification) JPEG-in-
+ TIFF encapsulation strategy, then tell our caller about them; otherwise,
+ keep mum.
+ */
+ case TIFFTAG_JPEGTABLES :
+ if (sp->jpegtables_length) /* we have "new"-style JPEG tables */
+ {
+ *va_arg(ap,uint32 *) = sp->jpegtables_length;
+ *va_arg(ap,char **) = sp->jpegtables;
+ return 1;
+ };
+
+ /* This pseudo tag indicates whether our caller is expected to do YCbCr <->
+ RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
+ ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
+ */
+ case TIFFTAG_JPEGCOLORMODE :
+ *va_arg(ap,uint32 *) = sp->jpegcolormode;
+ return 1;
+
+ /* The following tags are defined by the TIFF Version 6.0 specification
+ and are obsolete. If our caller asks for information about them, do not
+ return anything, even if we parsed them in an old-format "source" image.
+ */
+ case TIFFTAG_JPEGPROC :
+ *va_arg(ap, uint16*)=sp->jpegproc;
+ return(1);
+ break;
+ case TIFFTAG_JPEGIFOFFSET :
+ *va_arg(ap, uint32*)=sp->jpegifoffset;
+ return(1);
+ break;
+ case TIFFTAG_JPEGIFBYTECOUNT :
+ *va_arg(ap, uint32*)=sp->jpegifbytecount;
+ return(1);
+ break;
+ case TIFFTAG_JPEGRESTARTINTERVAL :
+ *va_arg(ap, uint32*)=sp->jpegrestartinterval;
+ return(1);
+ break;
+ case TIFFTAG_JPEGLOSSLESSPREDICTORS:
+ *va_arg(ap, uint32*)=sp->jpeglosslesspredictors_length;
+ *va_arg(ap, void**)=sp->jpeglosslesspredictors;
+ return(1);
+ break;
+ case TIFFTAG_JPEGPOINTTRANSFORM :
+ *va_arg(ap, uint32*)=sp->jpegpointtransform_length;
+ *va_arg(ap, void**)=sp->jpegpointtransform;
+ return(1);
+ break;
+ case TIFFTAG_JPEGQTABLES :
+ *va_arg(ap, uint32*)=sp->jpegqtables_length;
+ *va_arg(ap, void**)=sp->jpegqtables;
+ return(1);
+ break;
+ case TIFFTAG_JPEGDCTABLES :
+ *va_arg(ap, uint32*)=sp->jpegdctables_length;
+ *va_arg(ap, void**)=sp->jpegdctables;
+ return(1);
+ break;
+ case TIFFTAG_JPEGACTABLES :
+ *va_arg(ap, uint32*)=sp->jpegactables_length;
+ *va_arg(ap, void**)=sp->jpegactables;
+ return(1);
+ break;
+ };
+ return (*sp->vgetparent)(tif,tag,ap);
+ }
static void
-OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo)
-{
- (void)cinfo;
-}
-
-static boolean
-OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
-{
- TIFF* tif=(TIFF*)cinfo->client_data;
- OJPEGState* sp=(OJPEGState*)tif->tif_data;
- void* mem=0;
- uint32 len=0;
- if (OJPEGWriteStream(tif,&mem,&len)==0)
- {
- TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");
- jpeg_encap_unwind(tif);
- }
- sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=len;
- sp->libjpeg_jpeg_source_mgr.next_input_byte=mem;
- return(1);
-}
+OJPEGPrintDir(register TIFF *tif,FILE *fd,long flags)
+ { register OJPEGState *sp = OJState(tif);
+
+ if ( ( flags
+ & (TIFFPRINT_JPEGQTABLES|TIFFPRINT_JPEGDCTABLES|TIFFPRINT_JPEGACTABLES)
+ )
+ && sp->jpegtables_length
+ )
+ fprintf(fd," JPEG Table Data: <present>, %lu bytes\n",
+ sp->jpegtables_length);
+ }
+
+static uint32
+OJPEGDefaultStripSize(register TIFF *tif,register uint32 s)
+ { register OJPEGState *sp = OJState(tif);
+# define td (&tif->tif_dir)
+
+ if ((s = (*sp->defsparent)(tif,s)) < td->td_imagelength)
+ { register tsize_t size = sp->cinfo.comm.is_decompressor
+# ifdef D_LOSSLESS_SUPPORTED
+ ? sp->cinfo.d.min_codec_data_unit
+# else
+ ? DCTSIZE
+# endif
+# ifdef C_LOSSLESS_SUPPORTED
+ : sp->cinfo.c.data_unit;
+# else
+ : DCTSIZE;
+# endif
+
+ size = TIFFroundup(size,16);
+ s = TIFFroundup(s,td->td_ycbcrsubsampling[1]*size);
+ };
+ return s;
+# undef td
+ }
static void
-OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes)
-{
- TIFF* tif=(TIFF*)cinfo->client_data;
- (void)num_bytes;
- TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
- jpeg_encap_unwind(tif);
-}
-
-static boolean
-OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired)
-{
- TIFF* tif=(TIFF*)cinfo->client_data;
- (void)desired;
- TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
- jpeg_encap_unwind(tif);
- return(0);
-}
+OJPEGDefaultTileSize(register TIFF *tif,register uint32 *tw,register uint32 *th)
+ { register OJPEGState *sp = OJState(tif);
+ register tsize_t size;
+# define td (&tif->tif_dir)
+
+ size = sp->cinfo.comm.is_decompressor
+# ifdef D_LOSSLESS_SUPPORTED
+ ? sp->cinfo.d.min_codec_data_unit
+# else
+ ? DCTSIZE
+# endif
+# ifdef C_LOSSLESS_SUPPORTED
+ : sp->cinfo.c.data_unit;
+# else
+ : DCTSIZE;
+# endif
+ size = TIFFroundup(size,16);
+ (*sp->deftparent)(tif,tw,th);
+ *tw = TIFFroundup(*tw,td->td_ycbcrsubsampling[0]*size);
+ *th = TIFFroundup(*th,td->td_ycbcrsubsampling[1]*size);
+# undef td
+ }
static void
-OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo)
-{
- (void)cinfo;
-}
-
-#endif
+OJPEGCleanUp(register TIFF *tif)
+ { register OJPEGState *sp;
+
+ if ( (sp = OJState(tif)) )
+ {
+ CALLVJPEG(sp,jpeg_destroy(&sp->cinfo.comm)); /* Free JPEG Lib. vars. */
+ if (sp->jpegtables) {_TIFFfree(sp->jpegtables);sp->jpegtables=0;}
+ if (sp->jpeglosslesspredictors) {
+ _TIFFfree(sp->jpeglosslesspredictors);
+ sp->jpeglosslesspredictors = 0;
+ }
+ if (sp->jpegpointtransform) {
+ _TIFFfree(sp->jpegpointtransform);
+ sp->jpegpointtransform=0;
+ }
+ if (sp->jpegqtables) {_TIFFfree(sp->jpegqtables);sp->jpegqtables=0;}
+ if (sp->jpegactables) {_TIFFfree(sp->jpegactables);sp->jpegactables=0;}
+ if (sp->jpegdctables) {_TIFFfree(sp->jpegdctables);sp->jpegdctables=0;}
+ /* If the image file isn't "memory mapped" and we read it all into a
+ single, large memory buffer, free the buffer now.
+ */
+ if (!isMapped(tif) && tif->tif_base) /* free whole-file buffer */
+ {
+ _TIFFfree(tif->tif_base);
+ tif->tif_base = 0;
+ tif->tif_size = 0;
+ };
+ _TIFFfree(sp); /* Release local variables */
+ tif->tif_data = 0;
+ }
+ }
+int
+TIFFInitOJPEG(register TIFF *tif,int scheme)
+ { register OJPEGState *sp;
+# define td (&tif->tif_dir)
+# ifndef never
+
+ /* This module supports a decompression-only CODEC, which is intended strictly
+ for viewing old image files using the obsolete JPEG-in-TIFF encapsulation
+ specified by the TIFF Version 6.0 specification. It does not, and never
+ should, support compression for new images. If a client application asks us
+ to, refuse and complain loudly!
+ */
+ if (tif->tif_mode != O_RDONLY) return _notSupported(tif);
+# endif /* never */
+ if (!isMapped(tif))
+ {
+
+ /* BEWARE OF KLUDGE: If our host operating-system doesn't let an image
+ file be "memory mapped", then we want to read the
+ entire file into a single (possibly large) memory buffer as if it had
+ been "memory mapped". Although this is likely to waste space, because
+ analysis of the file's content might cause parts of it to be read into
+ smaller buffers duplicatively, it appears to be the lesser of several
+ evils. Very old JPEG-in-TIFF encapsulations aren't guaranteed to be
+ JFIF bit streams, or to have a TIFF "JPEGTables" record or much other
+ "metadata" to help us locate the decoding tables and entropy-coded data,
+ so we're likely do a lot of random-access grokking around, and we must
+ ultimately tell the JPEG Library to sequentially scan much of the file
+ anyway. This is all likely to be easier if we use "brute force" to
+ read the entire file, once, and don't use incremental disc I/O. If our
+ client application tries to process a file so big that we can't buffer
+ it entirely, then tough shit: we'll give up and exit!
+ */
+ if (!(tif->tif_base = _TIFFmalloc(tif->tif_size=TIFFGetFileSize(tif))))
+ {
+ TIFFError(tif->tif_name,"Cannot allocate file buffer");
+ return 0;
+ };
+ if (!SeekOK(tif,0) || !ReadOK(tif,tif->tif_base,tif->tif_size))
+ {
+ TIFFError(tif->tif_name,"Cannot read file");
+ return 0;
+ }
+ };
+
+ /* Allocate storage for this module's per-file variables. */
+
+ if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof *sp)))
+ {
+ TIFFError("TIFFInitOJPEG","No space for JPEG state block");
+ return 0;
+ };
+ (sp = OJState(tif))->tif = tif; /* Initialize reverse pointer */
+ sp->cinfo.d.err = jpeg_std_error(&sp->err); /* Initialize error handling */
+ sp->err.error_exit = TIFFojpeg_error_exit;
+ sp->err.output_message = TIFFojpeg_output_message;
+ if (!CALLVJPEG(sp,jpeg_create_decompress(&sp->cinfo.d))) return 0;
+
+ /* Install CODEC-specific tag information and override default TIFF Library
+ "method" subroutines with our own, CODEC-specific methods. Like all good
+ members of an object-class, we save some of these subroutine pointers for
+ "fall back" in case our own methods fail.
+ */
+ _TIFFMergeFieldInfo(tif,ojpegFieldInfo,
+ sizeof ojpegFieldInfo/sizeof *ojpegFieldInfo);
+ sp->defsparent = tif->tif_defstripsize;
+ sp->deftparent = tif->tif_deftilesize;
+ sp->vgetparent = tif->tif_tagmethods.vgetfield;
+ sp->vsetparent = tif->tif_tagmethods.vsetfield;
+ tif->tif_defstripsize = OJPEGDefaultStripSize;
+ tif->tif_deftilesize = OJPEGDefaultTileSize;
+ tif->tif_tagmethods.vgetfield = OJPEGVGetField;
+ tif->tif_tagmethods.vsetfield = OJPEGVSetField;
+ tif->tif_tagmethods.printdir = OJPEGPrintDir;
+# ifdef never
+ tif->tif_setupencode = OJPEGSetupEncode;
+ tif->tif_preencode = OJPEGPreEncode;
+ tif->tif_postencode = OJPEGPostEncode;
+# else /* well, hardly ever */
+ tif->tif_setupencode = tif->tif_postencode = _notSupported;
+ tif->tif_preencode = (TIFFPreMethod)_notSupported;
+# endif /* never */
+ tif->tif_setupdecode = OJPEGSetupDecode;
+ tif->tif_predecode = OJPEGPreDecode;
+ tif->tif_postdecode = OJPEGPostDecode;
+ tif->tif_cleanup = OJPEGCleanUp;
+
+ /* If the image file doesn't have "JPEGInterchangeFormat[Length]" TIFF records
+ to guide us, we have few clues about where its encapsulated JPEG bit stream
+ is located, so establish intelligent defaults: If the Image File Directory
+ doesn't immediately follow the TIFF header, assume that the JPEG data lies
+ in between; otherwise, assume that it follows the Image File Directory.
+ */
+ if (tif->tif_header.tiff_diroff > sizeof tif->tif_header)
+ {
+ sp->src.next_input_byte = tif->tif_base + sizeof tif->tif_header;
+ sp->src.bytes_in_buffer = tif->tif_header.tiff_diroff
+ - sizeof tif->tif_header;
+ }
+ else /* this case is ugly! */
+ { uint32 maxoffset = tif->tif_size;
+ uint16 dircount;
+
+ /* Calculate the offset to the next Image File Directory, if there is one,
+ or to the end of the file, if not. Then arrange to read the file from
+ the end of the Image File Directory to that offset.
+ */
+ if (tif->tif_nextdiroff) maxoffset = tif->tif_nextdiroff; /* Not EOF */
+ _TIFFmemcpy(&dircount,(const tdata_t)
+ (sp->src.next_input_byte = tif->tif_base+tif->tif_header.tiff_diroff),
+ sizeof dircount);
+ if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount);
+ sp->src.next_input_byte += dircount*sizeof(TIFFDirEntry)
+ + sizeof maxoffset + sizeof dircount;
+ sp->src.bytes_in_buffer = tif->tif_base - sp->src.next_input_byte
+ + maxoffset;
+ };
+
+ /* IJG JPEG Library Version 6B can be configured for either 8- or 12-bit sample
+ precision, but we assume that "old JPEG" TIFF clients only need 8 bits.
+ */
+ sp->cinfo.d.data_precision = 8;
+# ifdef C_LOSSLESS_SUPPORTED
+ /* If the "JPEGProc" TIFF tag is missing from the Image File Dictionary, the
+ JPEG Library will use its (lossy) baseline sequential process by default.
+ */
+ sp->cinfo.d.data_unit = DCTSIZE;
+# endif /* C_LOSSLESS_SUPPORTED */
+
+ /* Initialize other CODEC-specific variables requiring default values. */
+
+ tif->tif_flags |= TIFF_NOBITREV; /* No bit-reversal within data bytes */
+ sp->h_sampling = sp->v_sampling = 1; /* No subsampling by default */
+ sp->is_WANG = 0; /* Assume not a MS Windows Wang Imaging file by default */
+ sp->jpegtables = 0; /* No "new"-style JPEG tables synthesized yet */
+ sp->jpegtables_length = 0;
+ sp->jpegquality = 75; /* Default IJG quality */
+ sp->jpegcolormode = JPEGCOLORMODE_RAW;
+ sp->jpegtablesmode = 0; /* No tables found yet */
+ sp->jpeglosslesspredictors=0;
+ sp->jpeglosslesspredictors_length=0;
+ sp->jpegpointtransform=0;
+ sp->jpegpointtransform_length=0;
+ sp->jpegqtables=0;
+ sp->jpegqtables_length=0;
+ sp->jpegdctables=0;
+ sp->jpegdctables_length=0;
+ sp->jpegactables=0;
+ sp->jpegactables_length=0;
+ return 1;
+# undef td
+ }
+#endif /* OJPEG_SUPPORT */
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
diff --git a/src/libtiff/tif_open.c b/src/libtiff/tif_open.c
index 0ab465a..9adda1d 100644
--- a/src/libtiff/tif_open.c
+++ b/src/libtiff/tif_open.c
@@ -1,4 +1,4 @@
-/* $Id: tif_open.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_open.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -198,7 +198,7 @@ TIFFClientOpen(
*/
tif->tif_flags = FILLORDER_MSB2LSB;
if (m == O_RDONLY )
- tif->tif_flags |= TIFF_MAPPED;
+ tif->tif_flags |= TIFF_MAPPED;
#ifdef STRIPCHOP_DEFAULT
if (m == O_RDONLY || m == O_RDWR)
@@ -307,8 +307,7 @@ TIFFClientOpen(
if (tif->tif_mode & O_TRUNC ||
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
if (tif->tif_mode == O_RDONLY) {
- TIFFErrorExt(tif->tif_clientdata, name,
- "Cannot read TIFF header");
+ TIFFErrorExt(tif->tif_clientdata, name, "Cannot read TIFF header");
goto bad;
}
/*
@@ -337,8 +336,7 @@ TIFFClientOpen(
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
- TIFFErrorExt(tif->tif_clientdata, name,
- "Error writing TIFF header");
+ TIFFErrorExt(tif->tif_clientdata, name, "Error writing TIFF header");
goto bad;
}
/*
@@ -352,7 +350,6 @@ TIFFClientOpen(
goto bad;
tif->tif_diroff = 0;
tif->tif_dirlist = NULL;
- tif->tif_dirlistsize = 0;
tif->tif_dirnumber = 0;
return (tif);
}
@@ -369,12 +366,10 @@ TIFFClientOpen(
tif->tif_header.tiff_magic != MDI_LITTLEENDIAN
#endif
) {
- TIFFErrorExt(tif->tif_clientdata, name,
- "Not a TIFF or MDI file, bad magic number %d (0x%x)",
+ TIFFErrorExt(tif->tif_clientdata, name, "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)",
+ 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);
@@ -403,7 +398,7 @@ TIFFClientOpen(
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.tiff_version);
goto bad;
}
tif->tif_flags |= TIFF_MYBUFFER;
diff --git a/src/libtiff/tif_packbits.c b/src/libtiff/tif_packbits.c
index 3e857d9..965be6b 100644
--- a/src/libtiff/tif_packbits.c
+++ b/src/libtiff/tif_packbits.c
@@ -1,4 +1,4 @@
-/* $Id: tif_packbits.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_packbits.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -240,7 +240,7 @@ PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
if( occ < n )
{
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "PackBitsDecode: discarding %ld bytes "
+ "PackBitsDecode: discarding %d bytes "
"to avoid buffer overrun",
n - occ);
n = occ;
@@ -253,7 +253,7 @@ PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
if (occ < n + 1)
{
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "PackBitsDecode: discarding %ld bytes "
+ "PackBitsDecode: discarding %d bytes "
"to avoid buffer overrun",
n - occ + 1);
n = occ - 1;
diff --git a/src/libtiff/tif_pixarlog.c b/src/libtiff/tif_pixarlog.c
index b5f5c60..4779e6e 100644
--- a/src/libtiff/tif_pixarlog.c
+++ b/src/libtiff/tif_pixarlog.c
@@ -1,4 +1,4 @@
-/* $Id: tif_pixarlog.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_pixarlog.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1996-1997 Sam Leffler
@@ -327,7 +327,7 @@ horizontalAccumulate11(uint16 *wp, int n, int stride, uint16 *op)
while (n > 0) {
REPEAT(stride,
wp[stride] += *wp; *op = *wp&mask; wp++; op++)
- n -= stride;
+ n -= stride;
}
}
}
@@ -593,6 +593,7 @@ PixarLogMakeTables(PixarLogState *sp)
static int PixarLogEncode(TIFF*, tidata_t, tsize_t, tsample_t);
static int PixarLogDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+#define N(a) (sizeof(a)/sizeof(a[0]))
#define PIXARLOGDATAFMT_UNKNOWN -1
static int
@@ -767,18 +768,6 @@ 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);
- nsamples -= nsamples % llen;
- }
-
for (i = 0; i < nsamples; i += llen, up += llen) {
switch (sp->user_datafmt) {
case PIXARLOGDATAFMT_FLOAT:
@@ -1047,7 +1036,7 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
TIFFDirectory *td = &tif->tif_dir;
PixarLogState *sp = EncoderState(tif);
static const char module[] = "PixarLogEncode";
- int i, n, llen;
+ int i, n, llen;
unsigned short * up;
(void) s;
@@ -1289,22 +1278,10 @@ static const TIFFFieldInfo pixarlogFieldInfo[] = {
int
TIFFInitPixarLog(TIFF* tif, int scheme)
{
- static const char module[] = "TIFFInitPixarLog";
-
PixarLogState* sp;
assert(scheme == COMPRESSION_PIXARLOG);
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, pixarlogFieldInfo,
- TIFFArrayCount(pixarlogFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Merging PixarLog codec-specific tags failed");
- return 0;
- }
-
/*
* Allocate state block so tag methods have storage to record values.
*/
@@ -1334,6 +1311,7 @@ TIFFInitPixarLog(TIFF* tif, int scheme)
tif->tif_cleanup = PixarLogCleanup;
/* Override SetField so we can handle our private pseudo-tag */
+ _TIFFMergeFieldInfo(tif, pixarlogFieldInfo, N(pixarlogFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = PixarLogVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
@@ -1355,7 +1333,7 @@ TIFFInitPixarLog(TIFF* tif, int scheme)
return (1);
bad:
- TIFFErrorExt(tif->tif_clientdata, module,
+ TIFFErrorExt(tif->tif_clientdata, "TIFFInitPixarLog",
"No space for PixarLog state block");
return (0);
}
diff --git a/src/libtiff/tif_predict.c b/src/libtiff/tif_predict.c
index 3761d24..519b4aa 100644
--- a/src/libtiff/tif_predict.c
+++ b/src/libtiff/tif_predict.c
@@ -1,4 +1,4 @@
-/* $Id: tif_predict.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_predict.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -36,12 +36,9 @@
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);
@@ -63,8 +60,7 @@ PredictorSetup(TIFF* tif)
return 1;
case PREDICTOR_HORIZONTAL:
if (td->td_bitspersample != 8
- && td->td_bitspersample != 16
- && td->td_bitspersample != 32) {
+ && td->td_bitspersample != 16) {
TIFFErrorExt(tif->tif_clientdata, module,
"Horizontal differencing \"Predictor\" not supported with %d-bit samples",
td->td_bitspersample);
@@ -109,23 +105,19 @@ PredictorSetupDecode(TIFF* tif)
if (sp->predictor == 2) {
switch (td->td_bitspersample) {
- case 8: sp->decodepfunc = horAcc8; break;
- case 16: sp->decodepfunc = horAcc16; break;
- case 32: sp->decodepfunc = horAcc32; break;
+ case 8: sp->pfunc = horAcc8; break;
+ case 16: sp->pfunc = horAcc16; break;
}
/*
* Override default decoding method with one that does the
* predictor stuff.
*/
- if( tif->tif_decoderow != PredictorDecodeRow )
- {
- sp->decoderow = tif->tif_decoderow;
- tif->tif_decoderow = PredictorDecodeRow;
- sp->decodestrip = tif->tif_decodestrip;
- tif->tif_decodestrip = PredictorDecodeTile;
- sp->decodetile = tif->tif_decodetile;
- tif->tif_decodetile = PredictorDecodeTile;
- }
+ sp->coderow = tif->tif_decoderow;
+ tif->tif_decoderow = PredictorDecodeRow;
+ sp->codestrip = tif->tif_decodestrip;
+ tif->tif_decodestrip = PredictorDecodeTile;
+ sp->codetile = 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
@@ -134,31 +126,25 @@ PredictorSetupDecode(TIFF* tif)
* the library setup when the directory was read.
*/
if (tif->tif_flags & TIFF_SWAB) {
- if (sp->decodepfunc == horAcc16) {
- sp->decodepfunc = swabHorAcc16;
+ if (sp->pfunc == horAcc16) {
+ sp->pfunc = swabHorAcc16;
tif->tif_postdecode = _TIFFNoPostDecode;
- } else if (sp->decodepfunc == horAcc32) {
- sp->decodepfunc = swabHorAcc32;
- tif->tif_postdecode = _TIFFNoPostDecode;
- }
+ } /* else handle 32-bit case... */
}
}
else if (sp->predictor == 3) {
- sp->decodepfunc = fpAcc;
+ sp->pfunc = fpAcc;
/*
* Override default decoding method with one that does the
* predictor stuff.
*/
- if( tif->tif_decoderow != PredictorDecodeRow )
- {
- sp->decoderow = tif->tif_decoderow;
- tif->tif_decoderow = PredictorDecodeRow;
- sp->decodestrip = tif->tif_decodestrip;
- tif->tif_decodestrip = PredictorDecodeTile;
- sp->decodetile = tif->tif_decodetile;
- tif->tif_decodetile = PredictorDecodeTile;
- }
+ sp->coderow = tif->tif_decoderow;
+ tif->tif_decoderow = PredictorDecodeRow;
+ sp->codestrip = tif->tif_decodestrip;
+ tif->tif_decodestrip = PredictorDecodeTile;
+ sp->codetile = tif->tif_decodetile;
+ tif->tif_decodetile = PredictorDecodeTile;
/*
* The data should not be swapped outside of the floating
* point predictor, the accumulation routine should return
@@ -187,40 +173,33 @@ PredictorSetupEncode(TIFF* tif)
if (sp->predictor == 2) {
switch (td->td_bitspersample) {
- case 8: sp->encodepfunc = horDiff8; break;
- case 16: sp->encodepfunc = horDiff16; break;
- case 32: sp->encodepfunc = horDiff32; break;
+ case 8: sp->pfunc = horDiff8; break;
+ case 16: sp->pfunc = horDiff16; break;
}
/*
* Override default encoding method with one that does the
* predictor stuff.
*/
- if( tif->tif_encoderow != PredictorEncodeRow )
- {
- sp->encoderow = tif->tif_encoderow;
- tif->tif_encoderow = PredictorEncodeRow;
- sp->encodestrip = tif->tif_encodestrip;
- tif->tif_encodestrip = PredictorEncodeTile;
- sp->encodetile = tif->tif_encodetile;
- tif->tif_encodetile = PredictorEncodeTile;
- }
+ sp->coderow = tif->tif_encoderow;
+ tif->tif_encoderow = PredictorEncodeRow;
+ sp->codestrip = tif->tif_encodestrip;
+ tif->tif_encodestrip = PredictorEncodeTile;
+ sp->codetile = tif->tif_encodetile;
+ tif->tif_encodetile = PredictorEncodeTile;
}
else if (sp->predictor == 3) {
- sp->encodepfunc = fpDiff;
+ sp->pfunc = fpDiff;
/*
* Override default encoding method with one that does the
* predictor stuff.
*/
- if( tif->tif_encoderow != PredictorEncodeRow )
- {
- sp->encoderow = tif->tif_encoderow;
- tif->tif_encoderow = PredictorEncodeRow;
- sp->encodestrip = tif->tif_encodestrip;
- tif->tif_encodestrip = PredictorEncodeTile;
- sp->encodetile = tif->tif_encodetile;
- tif->tif_encodetile = PredictorEncodeTile;
- }
+ sp->coderow = tif->tif_encoderow;
+ tif->tif_encoderow = PredictorEncodeRow;
+ sp->codestrip = tif->tif_encodestrip;
+ tif->tif_encodestrip = PredictorEncodeTile;
+ sp->codetile = tif->tif_encodetile;
+ tif->tif_encodetile = PredictorEncodeTile;
}
return 1;
@@ -312,39 +291,6 @@ horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
}
}
-static void
-swabHorAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
-{
- tsize_t stride = PredictorState(tif)->stride;
- uint32* wp = (uint32*) cp0;
- tsize_t wc = cc / 4;
-
- if (wc > stride) {
- TIFFSwabArrayOfLong(wp, wc);
- wc -= stride;
- do {
- REPEAT4(stride, wp[stride] += wp[0]; wp++)
- wc -= stride;
- } while ((int32) wc > 0);
- }
-}
-
-static void
-horAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
-{
- tsize_t stride = PredictorState(tif)->stride;
- uint32* wp = (uint32*) cp0;
- tsize_t wc = cc / 4;
-
- if (wc > stride) {
- wc -= stride;
- do {
- REPEAT4(stride, wp[stride] += wp[0]; wp++)
- wc -= stride;
- } while ((int32) wc > 0);
- }
-}
-
/*
* Floating point predictor accumulation routine.
*/
@@ -391,11 +337,11 @@ PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
- assert(sp->decoderow != NULL);
- assert(sp->decodepfunc != NULL);
+ assert(sp->coderow != NULL);
+ assert(sp->pfunc != NULL);
- if ((*sp->decoderow)(tif, op0, occ0, s)) {
- (*sp->decodepfunc)(tif, op0, occ0);
+ if ((*sp->coderow)(tif, op0, occ0, s)) {
+ (*sp->pfunc)(tif, op0, occ0);
return 1;
} else
return 0;
@@ -414,14 +360,14 @@ PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
- assert(sp->decodetile != NULL);
+ assert(sp->codetile != NULL);
- if ((*sp->decodetile)(tif, op0, occ0, s)) {
+ if ((*sp->codetile)(tif, op0, occ0, s)) {
tsize_t rowsize = sp->rowsize;
assert(rowsize > 0);
- assert(sp->decodepfunc != NULL);
+ assert(sp->pfunc != NULL);
while ((long)occ0 > 0) {
- (*sp->decodepfunc)(tif, op0, (tsize_t) rowsize);
+ (*sp->pfunc)(tif, op0, (tsize_t) rowsize);
occ0 -= rowsize;
op0 += rowsize;
}
@@ -493,24 +439,6 @@ horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc)
}
}
-static void
-horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc)
-{
- TIFFPredictorState* sp = PredictorState(tif);
- tsize_t stride = sp->stride;
- int32 *wp = (int32*) cp0;
- tsize_t wc = cc/4;
-
- if (wc > stride) {
- wc -= stride;
- wp += wc - 1;
- do {
- REPEAT4(stride, wp[stride] -= wp[0]; wp--)
- wc -= stride;
- } while ((int32) wc > 0);
- }
-}
-
/*
* Floating point predictor differencing routine.
*/
@@ -553,56 +481,33 @@ PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
- assert(sp->encodepfunc != NULL);
- assert(sp->encoderow != NULL);
+ assert(sp->pfunc != NULL);
+ assert(sp->coderow != NULL);
/* XXX horizontal differencing alters user's data XXX */
- (*sp->encodepfunc)(tif, bp, cc);
- return (*sp->encoderow)(tif, bp, cc, s);
+ (*sp->pfunc)(tif, bp, cc);
+ return (*sp->coderow)(tif, bp, cc, s);
}
static int
PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
{
- static const char module[] = "PredictorEncodeTile";
TIFFPredictorState *sp = PredictorState(tif);
- uint8 *working_copy;
tsize_t cc = cc0, rowsize;
- unsigned char* bp;
- int result_code;
+ unsigned char* bp = bp0;
assert(sp != NULL);
- assert(sp->encodepfunc != NULL);
- assert(sp->encodetile != NULL);
-
- /*
- * Do predictor manipulation in a working buffer to avoid altering
- * the callers buffer. http://trac.osgeo.org/gdal/ticket/1965
- */
- working_copy = (uint8*) _TIFFmalloc(cc0);
- if( working_copy == NULL )
- {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Out of memory allocating %d byte temp buffer.",
- cc0 );
- return 0;
- }
- memcpy( working_copy, bp0, cc0 );
- bp = working_copy;
+ assert(sp->pfunc != NULL);
+ assert(sp->codetile != NULL);
rowsize = sp->rowsize;
assert(rowsize > 0);
- assert((cc0%rowsize)==0);
- while (cc > 0) {
- (*sp->encodepfunc)(tif, bp, rowsize);
+ while ((long)cc > 0) {
+ (*sp->pfunc)(tif, bp, (tsize_t) rowsize);
cc -= rowsize;
bp += rowsize;
}
- result_code = (*sp->encodetile)(tif, working_copy, cc0, s);
-
- _TIFFfree( working_copy );
-
- return result_code;
+ return (*sp->codetile)(tif, bp0, cc0, s);
}
#define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */
@@ -611,6 +516,7 @@ static const TIFFFieldInfo predictFieldInfo[] = {
{ TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, FIELD_PREDICTOR,
FALSE, FALSE, "Predictor" },
};
+#define N(a) (sizeof (a) / sizeof (a[0]))
static int
PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
@@ -677,18 +583,10 @@ TIFFPredictorInit(TIFF* tif)
assert(sp != 0);
/*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, predictFieldInfo,
- TIFFArrayCount(predictFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, "TIFFPredictorInit",
- "Merging Predictor codec-specific tags failed");
- return 0;
- }
-
- /*
- * Override parent get/set field methods.
+ * Merge codec-specific tag information and
+ * override parent get/set field methods.
*/
+ _TIFFMergeFieldInfo(tif, predictFieldInfo, N(predictFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield =
PredictorVGetField;/* hook for predictor tag */
@@ -705,8 +603,7 @@ TIFFPredictorInit(TIFF* tif)
tif->tif_setupencode = PredictorSetupEncode;
sp->predictor = 1; /* default value */
- sp->encodepfunc = NULL; /* no predictor routine */
- sp->decodepfunc = NULL; /* no predictor routine */
+ sp->pfunc = NULL; /* no predictor routine */
return 1;
}
diff --git a/src/libtiff/tif_predict.h b/src/libtiff/tif_predict.h
index 4a1e9ab..62b1e07 100644
--- a/src/libtiff/tif_predict.h
+++ b/src/libtiff/tif_predict.h
@@ -1,4 +1,4 @@
-/* $Id: tif_predict.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_predict.h,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
@@ -40,16 +40,10 @@ typedef struct {
int stride; /* sample stride over data */
tsize_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 */
-
+ TIFFPostMethod pfunc; /* horizontal differencer/accumulator */
+ TIFFCodeMethod coderow; /* parent codec encode/decode row */
+ TIFFCodeMethod codestrip; /* parent codec encode/decode strip */
+ TIFFCodeMethod codetile; /* parent codec encode/decode tile */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
diff --git a/src/libtiff/tif_print.c b/src/libtiff/tif_print.c
index c3c3455..e3d1479 100644
--- a/src/libtiff/tif_print.c
+++ b/src/libtiff/tif_print.c
@@ -1,4 +1,4 @@
-/* $Id: tif_print.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_print.c,v 1.4 2010/01/26 15:56:36 scuri 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[] = {
@@ -491,7 +491,7 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
} else
fprintf(fd, "(present)\n");
}
- if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) {
+ if (TIFFFieldSet(tif, FIELD_SUBIFD)) {
fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++)
fprintf(fd, " %5lu", (long) td->td_subifd[i]);
@@ -509,7 +509,7 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
for(i = 0; i < count; i++) {
ttag_t tag = TIFFGetTagListEntry(tif, i);
const TIFFFieldInfo *fip;
- uint32 value_count;
+ uint16 value_count;
int mem_alloc = 0;
void *raw_data;
diff --git a/src/libtiff/tif_read.c b/src/libtiff/tif_read.c
index a0c898c..445fa30 100644
--- a/src/libtiff/tif_read.c
+++ b/src/libtiff/tif_read.c
@@ -1,4 +1,4 @@
-/* $Id: tif_read.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_read.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -50,10 +50,8 @@ TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
tstrip_t strip;
if (row >= td->td_imagelength) { /* out of range */
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%lu: Row out of range, max %lu",
- (unsigned long) row,
- (unsigned long) td->td_imagelength);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%lu: Row out of range, max %lu",
+ (unsigned long) row, (unsigned long) td->td_imagelength);
return (0);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
@@ -66,7 +64,7 @@ TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
} else
strip = row / td->td_rowsperstrip;
- if (strip != tif->tif_curstrip) { /* different strip, refill */
+ if (strip != tif->tif_curstrip) { /* different strip, refill */
if (!TIFFFillStrip(tif, strip))
return (0);
} else if (row < tif->tif_row) {
@@ -106,8 +104,8 @@ TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
e = (*tif->tif_decoderow)
(tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
- /* we are now poised at the beginning of the next row */
- tif->tif_row = row + 1;
+ /* we are now poised at the beginning of the next row */
+ tif->tif_row = row + 1;
if (e)
(*tif->tif_postdecode)(tif, (tidata_t) buf,
@@ -131,23 +129,22 @@ TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
if (!TIFFCheckRead(tif, 0))
return (-1);
if (strip >= td->td_nstrips) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%ld: Strip out of range, max %ld",
- (long) strip, (long) td->td_nstrips);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%ld: Strip out of range, max %ld",
+ (long) strip, (long) td->td_nstrips);
return (-1);
}
/*
* Calculate the strip size according to the number of
* rows in the strip (check for truncated last strip on any
- * of the separations).
+ * of the separations).
*/
- if( td->td_rowsperstrip >= td->td_imagelength )
- strips_per_sep = 1;
- else
- strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
- / td->td_rowsperstrip;
+ if( td->td_rowsperstrip >= td->td_imagelength )
+ strips_per_sep = 1;
+ else
+ strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
+ / td->td_rowsperstrip;
- sep_strip = strip % strips_per_sep;
+ sep_strip = strip % strips_per_sep;
if (sep_strip != strips_per_sep-1 ||
(nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
@@ -158,9 +155,9 @@ TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
size = stripsize;
else if (size > stripsize)
size = stripsize;
- if (TIFFFillStrip(tif, strip)
- && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,
- (tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
+ if (TIFFFillStrip(tif, strip)
+ && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,
+ (tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
return (size);
} else
@@ -173,7 +170,6 @@ TIFFReadRawStrip1(TIFF* tif,
{
TIFFDirectory *td = &tif->tif_dir;
- assert((tif->tif_flags&TIFF_NOREADRAW)==0);
if (!isMapped(tif)) {
tsize_t cc;
@@ -219,27 +215,13 @@ TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
{
static const char module[] = "TIFFReadRawStrip";
TIFFDirectory *td = &tif->tif_dir;
- /*
- * FIXME: butecount should have tsize_t type, but for now libtiff
- * defines tsize_t as a signed 32-bit integer and we are losing
- * ability to read arrays larger than 2^31 bytes. So we are using
- * uint32 instead of tsize_t here.
- */
- uint32 bytecount;
+ tsize_t bytecount;
if (!TIFFCheckRead(tif, 0))
return ((tsize_t) -1);
if (strip >= td->td_nstrips) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%lu: Strip out of range, max %lu",
- (unsigned long) strip,
- (unsigned long) td->td_nstrips);
- return ((tsize_t) -1);
- }
- if (tif->tif_flags&TIFF_NOREADRAW)
- {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Compression scheme does not support access to raw uncompressed data");
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%lu: Strip out of range, max %lu",
+ (unsigned long) strip, (unsigned long) td->td_nstrips);
return ((tsize_t) -1);
}
bytecount = td->td_stripbytecount[strip];
@@ -249,110 +231,88 @@ TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
(unsigned long) bytecount, (unsigned long) strip);
return ((tsize_t) -1);
}
- if (size != (tsize_t)-1 && (uint32)size < bytecount)
+ if (size != (tsize_t)-1 && size < bytecount)
bytecount = size;
return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
}
/*
- * Read the specified strip and setup for decoding. The data buffer is
- * expanded, as necessary, to hold the strip's data.
+ * Read the specified strip and setup for decoding.
+ * The data buffer is expanded, as necessary, to
+ * hold the strip's data.
*/
int
TIFFFillStrip(TIFF* tif, tstrip_t strip)
{
static const char module[] = "TIFFFillStrip";
TIFFDirectory *td = &tif->tif_dir;
+ tsize_t bytecount;
- if ((tif->tif_flags&TIFF_NOREADRAW)==0)
- {
+ 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);
+ return (0);
+ }
+ if (isMapped(tif) &&
+ (isFillOrder(tif, td->td_fillorder)
+ || (tif->tif_flags & TIFF_NOBITREV))) {
/*
- * FIXME: butecount should have tsize_t type, but for now
- * libtiff defines tsize_t as a signed 32-bit integer and we
- * are losing ability to read arrays larger than 2^31 bytes.
- * So we are using uint32 instead of tsize_t here.
+ * The image is mapped into memory and we either don't
+ * need to flip bits or the compression routine is going
+ * to handle this operation itself. In this case, avoid
+ * copying the raw data and instead just reference the
+ * data from the memory mapped file image. This assumes
+ * that the decompression routines do not modify the
+ * contents of the raw data buffer (if they try to,
+ * the application will get a fault since the file is
+ * mapped read-only).
*/
- uint32 bytecount = td->td_stripbytecount[strip];
- if (bytecount <= 0) {
+ if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
+ _TIFFfree(tif->tif_rawdata);
+ tif->tif_flags &= ~TIFF_MYBUFFER;
+ if ( td->td_stripoffset[strip] + bytecount > tif->tif_size) {
+ /*
+ * This error message might seem strange, but it's
+ * what would happen if a read were done instead.
+ */
TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Invalid strip byte count %lu, strip %lu",
- tif->tif_name, (unsigned long) bytecount,
- (unsigned long) strip);
+ "%s: Read error on strip %lu; got %lu bytes, expected %lu",
+ tif->tif_name,
+ (unsigned long) strip,
+ (unsigned long) tif->tif_size - td->td_stripoffset[strip],
+ (unsigned long) bytecount);
+ tif->tif_curstrip = NOSTRIP;
return (0);
}
- if (isMapped(tif) &&
- (isFillOrder(tif, td->td_fillorder)
- || (tif->tif_flags & TIFF_NOBITREV))) {
- /*
- * The image is mapped into memory and we either don't
- * need to flip bits or the compression routine is
- * going to handle this operation itself. In this
- * case, avoid copying the raw data and instead just
- * reference the data from the memory mapped file
- * image. This assumes that the decompression
- * routines do not modify the contents of the raw data
- * buffer (if they try to, the application will get a
- * fault since the file is mapped read-only).
- */
- if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
- _TIFFfree(tif->tif_rawdata);
- tif->tif_flags &= ~TIFF_MYBUFFER;
- /*
- * We must check for overflow, potentially causing
- * an OOB read. Instead of simple
- *
- * td->td_stripoffset[strip]+bytecount > tif->tif_size
- *
- * comparison (which can overflow) we do the following
- * two comparisons:
- */
- if (bytecount > tif->tif_size ||
- td->td_stripoffset[strip] > tif->tif_size - bytecount) {
- /*
- * This error message might seem strange, but
- * it's what would happen if a read were done
- * instead.
- */
+ tif->tif_rawdatasize = bytecount;
+ tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
+ } else {
+ /*
+ * Expand raw data buffer, if needed, to
+ * hold data strip coming from file
+ * (perhaps should set upper bound on
+ * the size of a buffer we'll use?).
+ */
+ if (bytecount > tif->tif_rawdatasize) {
+ tif->tif_curstrip = NOSTRIP;
+ if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
TIFFErrorExt(tif->tif_clientdata, module,
-
- "%s: Read error on strip %lu; "
- "got %lu bytes, expected %lu",
- tif->tif_name, (unsigned long) strip,
- (unsigned long) tif->tif_size - td->td_stripoffset[strip],
- (unsigned long) bytecount);
- tif->tif_curstrip = NOSTRIP;
- return (0);
- }
- tif->tif_rawdatasize = bytecount;
- tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
- } else {
- /*
- * Expand raw data buffer, if needed, to hold data
- * strip coming from file (perhaps should set upper
- * bound on the size of a buffer we'll use?).
- */
- if (bytecount > (uint32)tif->tif_rawdatasize) {
- tif->tif_curstrip = NOSTRIP;
- if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
- TIFFErrorExt(tif->tif_clientdata,
- module,
"%s: Data buffer too small to hold strip %lu",
- tif->tif_name,
- (unsigned long) strip);
- return (0);
- }
- if (!TIFFReadBufferSetup(tif, 0,
- TIFFroundup(bytecount, 1024)))
- return (0);
+ tif->tif_name, (unsigned long) strip);
+ return (0);
}
- if ((uint32)TIFFReadRawStrip1(tif, strip,
- (unsigned char *)tif->tif_rawdata,
- bytecount, module) != bytecount)
+ if (!TIFFReadBufferSetup(tif, 0,
+ TIFFroundup(bytecount, 1024)))
return (0);
- if (!isFillOrder(tif, td->td_fillorder) &&
- (tif->tif_flags & TIFF_NOBITREV) == 0)
- TIFFReverseBits(tif->tif_rawdata, bytecount);
}
+ if (TIFFReadRawStrip1(tif, strip, (unsigned char *)tif->tif_rawdata,
+ bytecount, module) != bytecount)
+ return (0);
+ if (!isFillOrder(tif, td->td_fillorder) &&
+ (tif->tif_flags & TIFF_NOBITREV) == 0)
+ TIFFReverseBits(tif->tif_rawdata, bytecount);
}
return (TIFFStartStrip(tif, strip));
}
@@ -389,9 +349,8 @@ TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
if (!TIFFCheckRead(tif, 1))
return (-1);
if (tile >= td->td_nstrips) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%ld: Tile out of range, max %ld",
- (long) tile, (unsigned long) td->td_nstrips);
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%ld: Tile out of range, max %ld",
+ (long) tile, (unsigned long) td->td_nstrips);
return (-1);
}
if (size == (tsize_t) -1)
@@ -412,7 +371,6 @@ TIFFReadRawTile1(TIFF* tif,
{
TIFFDirectory *td = &tif->tif_dir;
- assert((tif->tif_flags&TIFF_NOREADRAW)==0);
if (!isMapped(tif)) {
tsize_t cc;
@@ -461,121 +419,89 @@ TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
{
static const char module[] = "TIFFReadRawTile";
TIFFDirectory *td = &tif->tif_dir;
- /*
- * FIXME: butecount should have tsize_t type, but for now libtiff
- * defines tsize_t as a signed 32-bit integer and we are losing
- * ability to read arrays larger than 2^31 bytes. So we are using
- * uint32 instead of tsize_t here.
- */
- uint32 bytecount;
+ tsize_t bytecount;
if (!TIFFCheckRead(tif, 1))
return ((tsize_t) -1);
if (tile >= td->td_nstrips) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%lu: Tile out of range, max %lu",
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%lu: Tile out of range, max %lu",
(unsigned long) tile, (unsigned long) td->td_nstrips);
return ((tsize_t) -1);
}
- if (tif->tif_flags&TIFF_NOREADRAW)
- {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Compression scheme does not support access to raw uncompressed data");
- return ((tsize_t) -1);
- }
bytecount = td->td_stripbytecount[tile];
- if (size != (tsize_t) -1 && (uint32)size < bytecount)
+ if (size != (tsize_t) -1 && size < bytecount)
bytecount = size;
return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
}
/*
- * Read the specified tile and setup for decoding. The data buffer is
- * expanded, as necessary, to hold the tile's data.
+ * Read the specified tile and setup for decoding.
+ * The data buffer is expanded, as necessary, to
+ * hold the tile's data.
*/
int
TIFFFillTile(TIFF* tif, ttile_t tile)
{
static const char module[] = "TIFFFillTile";
TIFFDirectory *td = &tif->tif_dir;
+ tsize_t bytecount;
- if ((tif->tif_flags&TIFF_NOREADRAW)==0)
- {
+ bytecount = td->td_stripbytecount[tile];
+ if (bytecount <= 0) {
+ TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+ "%lu: Invalid tile byte count, tile %lu",
+ (unsigned long) bytecount, (unsigned long) tile);
+ return (0);
+ }
+ if (isMapped(tif) &&
+ (isFillOrder(tif, td->td_fillorder)
+ || (tif->tif_flags & TIFF_NOBITREV))) {
/*
- * FIXME: butecount should have tsize_t type, but for now
- * libtiff defines tsize_t as a signed 32-bit integer and we
- * are losing ability to read arrays larger than 2^31 bytes.
- * So we are using uint32 instead of tsize_t here.
+ * The image is mapped into memory and we either don't
+ * need to flip bits or the compression routine is going
+ * to handle this operation itself. In this case, avoid
+ * copying the raw data and instead just reference the
+ * data from the memory mapped file image. This assumes
+ * that the decompression routines do not modify the
+ * contents of the raw data buffer (if they try to,
+ * the application will get a fault since the file is
+ * mapped read-only).
*/
- uint32 bytecount = td->td_stripbytecount[tile];
- if (bytecount <= 0) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%lu: Invalid tile byte count, tile %lu",
- (unsigned long) bytecount, (unsigned long) tile);
+ if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
+ _TIFFfree(tif->tif_rawdata);
+ tif->tif_flags &= ~TIFF_MYBUFFER;
+ if ( td->td_stripoffset[tile] + bytecount > tif->tif_size) {
+ tif->tif_curtile = NOTILE;
return (0);
}
- if (isMapped(tif) &&
- (isFillOrder(tif, td->td_fillorder)
- || (tif->tif_flags & TIFF_NOBITREV))) {
- /*
- * The image is mapped into memory and we either don't
- * need to flip bits or the compression routine is
- * going to handle this operation itself. In this
- * case, avoid copying the raw data and instead just
- * reference the data from the memory mapped file
- * image. This assumes that the decompression
- * routines do not modify the contents of the raw data
- * buffer (if they try to, the application will get a
- * fault since the file is mapped read-only).
- */
- if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
- _TIFFfree(tif->tif_rawdata);
- tif->tif_flags &= ~TIFF_MYBUFFER;
- /*
- * We must check for overflow, potentially causing
- * an OOB read. Instead of simple
- *
- * td->td_stripoffset[tile]+bytecount > tif->tif_size
- *
- * comparison (which can overflow) we do the following
- * two comparisons:
- */
- if (bytecount > tif->tif_size ||
- td->td_stripoffset[tile] > tif->tif_size - bytecount) {
- tif->tif_curtile = NOTILE;
- return (0);
- }
- tif->tif_rawdatasize = bytecount;
- tif->tif_rawdata =
- tif->tif_base + td->td_stripoffset[tile];
- } else {
- /*
- * Expand raw data buffer, if needed, to hold data
- * tile coming from file (perhaps should set upper
- * bound on the size of a buffer we'll use?).
- */
- if (bytecount > (uint32)tif->tif_rawdatasize) {
- tif->tif_curtile = NOTILE;
- if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
- TIFFErrorExt(tif->tif_clientdata,
- module,
+ tif->tif_rawdatasize = bytecount;
+ tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile];
+ } else {
+ /*
+ * Expand raw data buffer, if needed, to
+ * hold data tile coming from file
+ * (perhaps should set upper bound on
+ * the size of a buffer we'll use?).
+ */
+ if (bytecount > tif->tif_rawdatasize) {
+ tif->tif_curtile = NOTILE;
+ if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
+ TIFFErrorExt(tif->tif_clientdata, module,
"%s: Data buffer too small to hold tile %ld",
- tif->tif_name,
- (long) tile);
- return (0);
- }
- if (!TIFFReadBufferSetup(tif, 0,
- TIFFroundup(bytecount, 1024)))
- return (0);
+ tif->tif_name, (long) tile);
+ return (0);
}
- if ((uint32)TIFFReadRawTile1(tif, tile,
- (unsigned char *)tif->tif_rawdata,
- bytecount, module) != bytecount)
+ if (!TIFFReadBufferSetup(tif, 0,
+ TIFFroundup(bytecount, 1024)))
return (0);
- if (!isFillOrder(tif, td->td_fillorder) &&
- (tif->tif_flags & TIFF_NOBITREV) == 0)
- TIFFReverseBits(tif->tif_rawdata, bytecount);
}
+ if (TIFFReadRawTile1(tif, tile,
+ (unsigned char *)tif->tif_rawdata,
+ bytecount, module) != bytecount)
+ return (0);
+ if (!isFillOrder(tif, td->td_fillorder) &&
+ (tif->tif_flags & TIFF_NOBITREV) == 0)
+ TIFFReverseBits(tif->tif_rawdata, bytecount);
}
return (TIFFStartTile(tif, tile));
}
@@ -594,7 +520,6 @@ TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
{
static const char module[] = "TIFFReadBufferSetup";
- assert((tif->tif_flags&TIFF_NOREADRAW)==0);
if (tif->tif_rawdata) {
if (tif->tif_flags & TIFF_MYBUFFER)
_TIFFfree(tif->tif_rawdata);
@@ -635,16 +560,8 @@ TIFFStartStrip(TIFF* tif, tstrip_t strip)
}
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
- if (tif->tif_flags&TIFF_NOREADRAW)
- {
- tif->tif_rawcp = NULL;
- tif->tif_rawcc = 0;
- }
- else
- {
- tif->tif_rawcp = tif->tif_rawdata;
- tif->tif_rawcc = td->td_stripbytecount[strip];
- }
+ tif->tif_rawcp = tif->tif_rawdata;
+ tif->tif_rawcc = td->td_stripbytecount[strip];
return ((*tif->tif_predecode)(tif,
(tsample_t)(strip / td->td_stripsperimage)));
}
@@ -670,16 +587,8 @@ TIFFStartTile(TIFF* tif, ttile_t tile)
tif->tif_col =
(tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
td->td_tilewidth;
- if (tif->tif_flags&TIFF_NOREADRAW)
- {
- tif->tif_rawcp = NULL;
- tif->tif_rawcc = 0;
- }
- else
- {
- tif->tif_rawcp = tif->tif_rawdata;
- tif->tif_rawcc = td->td_stripbytecount[tile];
- }
+ tif->tif_rawcp = tif->tif_rawdata;
+ tif->tif_rawcc = td->td_stripbytecount[tile];
return ((*tif->tif_predecode)(tif,
(tsample_t)(tile/td->td_stripsperimage)));
}
diff --git a/src/libtiff/tif_strip.c b/src/libtiff/tif_strip.c
index 0c4f3a0..e1d7875 100644
--- a/src/libtiff/tif_strip.c
+++ b/src/libtiff/tif_strip.c
@@ -1,4 +1,4 @@
-/* $Id: tif_strip.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_strip.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@@ -121,12 +121,12 @@ TIFFVStripSize(TIFF* tif, uint32 nrows)
* horizontal/vertical subsampling area include
* YCbCr data for the extended image.
*/
- uint16 ycbcrsubsampling[2];
- tsize_t w, scanline, samplingarea;
+ uint16 ycbcrsubsampling[2];
+ tsize_t w, scanline, samplingarea;
- TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
- ycbcrsubsampling + 0,
- ycbcrsubsampling + 1 );
+ TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
+ ycbcrsubsampling + 0,
+ ycbcrsubsampling + 1 );
samplingarea = ycbcrsubsampling[0]*ycbcrsubsampling[1];
if (samplingarea == 0) {
@@ -228,13 +228,13 @@ 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];
- TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING,
+ TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0,
ycbcrsubsampling + 1);
@@ -267,75 +267,6 @@ TIFFScanlineSize(TIFF* tif)
"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
- * this number may be 1/samples-per-pixel if data is
- * stored as separate planes.
- * The ScanlineSize in case of YCbCrSubsampling is defined as the
- * 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)
-{
- 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];
-
- TIFFGetField(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;
- }
-
- 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");
- }
- } else
- scanline = td->td_imagewidth;
- return ((tsize_t) TIFFhowmany8(multiply(tif, scanline,
- td->td_bitspersample,
- "TIFFScanlineSize")));
-}
-
/*
* Return the number of bytes required to store a complete
* decoded and packed raster scanline (as opposed to the
diff --git a/src/libtiff/tif_swab.c b/src/libtiff/tif_swab.c
index 82008ad..b36297a 100644
--- a/src/libtiff/tif_swab.c
+++ b/src/libtiff/tif_swab.c
@@ -1,4 +1,4 @@
-/* $Id: tif_swab.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_swab.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_thunder.c b/src/libtiff/tif_thunder.c
index e75ad4a..6146e81 100644
--- a/src/libtiff/tif_thunder.c
+++ b/src/libtiff/tif_thunder.c
@@ -1,4 +1,4 @@
-/* $Id: tif_thunder.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_thunder.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_tile.c b/src/libtiff/tif_tile.c
index 6bb87df..727990f 100644
--- a/src/libtiff/tif_tile.c
+++ b/src/libtiff/tif_tile.c
@@ -1,4 +1,4 @@
-/* $Id: tif_tile.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_tile.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
diff --git a/src/libtiff/tif_version.c b/src/libtiff/tif_version.c
index 710805b..771e1ce 100644
--- a/src/libtiff/tif_version.c
+++ b/src/libtiff/tif_version.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_version.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_version.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1992-1997 Sam Leffler
* Copyright (c) 1992-1997 Silicon Graphics, Inc.
diff --git a/src/libtiff/tif_warning.c b/src/libtiff/tif_warning.c
index e76ed8d..e2a8bc9 100644
--- a/src/libtiff/tif_warning.c
+++ b/src/libtiff/tif_warning.c
@@ -1,4 +1,4 @@
-/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_warning.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Header: /cvsroot/imtoolkit/im/src/libtiff/tif_warning.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
diff --git a/src/libtiff/tif_write.c b/src/libtiff/tif_write.c
index 8a90fc7..9650a07 100644
--- a/src/libtiff/tif_write.c
+++ b/src/libtiff/tif_write.c
@@ -1,4 +1,4 @@
-/* $Id: tif_write.c,v 1.4 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_write.c,v 1.5 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -227,8 +227,10 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
if( td->td_stripbytecount[strip] > 0 )
{
- /* Force TIFFAppendToStrip() to consider placing data at end
- of file. */
+ /* if we are writing over existing tiles, zero length. */
+ td->td_stripbytecount[strip] = 0;
+
+ /* this forces TIFFAppendToStrip() to do a seek */
tif->tif_curoff = 0;
}
@@ -361,8 +363,10 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
if( td->td_stripbytecount[tile] > 0 )
{
- /* Force TIFFAppendToStrip() to consider placing data at end
- of file. */
+ /* if we are writing over existing tiles, zero length. */
+ td->td_stripbytecount[tile] = 0;
+
+ /* this forces TIFFAppendToStrip() to do a seek */
tif->tif_curoff = 0;
}
@@ -517,8 +521,7 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
* because this field is used in other parts of library even
* in the single band case.
*/
- if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG))
- tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
+ tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
} else {
if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
TIFFErrorExt(tif->tif_clientdata, module,
@@ -622,53 +625,64 @@ TIFFGrowStrips(TIFF* tif, int delta, const char* module)
static int
TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
{
- static const char module[] = "TIFFAppendToStrip";
TIFFDirectory *td = &tif->tif_dir;
+ static const char module[] = "TIFFAppendToStrip";
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 )
- {
- /*
- * There is already tile data on disk, and the new tile
- * data we have to 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.
- */
- if (!SeekOK(tif, td->td_stripoffset[strip])) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Seek error at scanline %lu",
- (unsigned long)tif->tif_row);
- return (0);
- }
- }
- else
- {
- /*
- * Seek to end of file, and set that as our location to
- * write this strip.
- */
- td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END);
- }
-
- tif->tif_curoff = td->td_stripoffset[strip];
-
- /*
- * We are starting a fresh strip/tile, so set the size to zero.
- */
- td->td_stripbytecount[strip] = 0;
+ /*
+ * No current offset, set the current strip.
+ */
+ assert(td->td_nstrips > 0);
+ if (td->td_stripoffset[strip] != 0) {
+ /*
+ * Prevent overlapping of the data chunks. We need
+ * this to enable in place updating of the compressed
+ * images. Larger blocks will be moved at the end of
+ * the file without any optimization of the spare
+ * space, so such scheme is not too much effective.
+ */
+ if (td->td_stripbytecountsorted) {
+ if (strip == td->td_nstrips - 1
+ || td->td_stripoffset[strip + 1] <
+ td->td_stripoffset[strip] + cc) {
+ td->td_stripoffset[strip] =
+ TIFFSeekFile(tif, (toff_t)0,
+ SEEK_END);
+ }
+ } else {
+ tstrip_t i;
+ for (i = 0; i < td->td_nstrips; i++) {
+ if (td->td_stripoffset[i] >
+ td->td_stripoffset[strip]
+ && td->td_stripoffset[i] <
+ td->td_stripoffset[strip] + cc) {
+ td->td_stripoffset[strip] =
+ TIFFSeekFile(tif,
+ (toff_t)0,
+ SEEK_END);
+ }
+ }
+ }
+
+ if (!SeekOK(tif, td->td_stripoffset[strip])) {
+ TIFFErrorExt(tif->tif_clientdata, module,
+ "%s: Seek error at scanline %lu",
+ tif->tif_name,
+ (unsigned long)tif->tif_row);
+ return (0);
+ }
+ } else
+ td->td_stripoffset[strip] =
+ TIFFSeekFile(tif, (toff_t) 0, SEEK_END);
+ tif->tif_curoff = td->td_stripoffset[strip];
}
if (!WriteOK(tif, data, cc)) {
- TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
- (unsigned long) tif->tif_row);
- return (0);
+ TIFFErrorExt(tif->tif_clientdata, module, "%s: Write error at scanline %lu",
+ tif->tif_name, (unsigned long) tif->tif_row);
+ return (0);
}
- tif->tif_curoff = tif->tif_curoff+cc;
+ tif->tif_curoff += cc;
td->td_stripbytecount[strip] += cc;
return (1);
}
diff --git a/src/libtiff/tif_zip.c b/src/libtiff/tif_zip.c
index 35ae791..62f32ab 100644
--- a/src/libtiff/tif_zip.c
+++ b/src/libtiff/tif_zip.c
@@ -1,4 +1,4 @@
-/* $Id: tif_zip.c,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tif_zip.c,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
@@ -70,8 +70,7 @@ typedef struct {
z_stream stream;
int zipquality; /* compression level */
int state; /* state flags */
-#define ZSTATE_INIT_DECODE 0x01
-#define ZSTATE_INIT_ENCODE 0x02
+#define ZSTATE_INIT 0x1 /* zlib setup successfully */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
@@ -91,18 +90,11 @@ ZIPSetupDecode(TIFF* tif)
static const char module[] = "ZIPSetupDecode";
assert(sp != NULL);
-
- /* if we were last encoding, terminate this mode */
- if (sp->state & ZSTATE_INIT_ENCODE) {
- 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);
return (0);
} else {
- sp->state |= ZSTATE_INIT_DECODE;
+ sp->state |= ZSTATE_INIT;
return (1);
}
}
@@ -117,10 +109,6 @@ ZIPPreDecode(TIFF* tif, tsample_t s)
(void) s;
assert(sp != NULL);
-
- 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;
return (inflateReset(&sp->stream) == Z_OK);
@@ -134,8 +122,6 @@ ZIPDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
(void) s;
assert(sp != NULL);
- assert(sp->state == ZSTATE_INIT_DECODE);
-
sp->stream.next_out = op;
sp->stream.avail_out = occ;
do {
@@ -172,16 +158,11 @@ ZIPSetupEncode(TIFF* tif)
static const char module[] = "ZIPSetupEncode";
assert(sp != NULL);
- if (sp->state & ZSTATE_INIT_DECODE) {
- 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);
return (0);
} else {
- sp->state |= ZSTATE_INIT_ENCODE;
+ sp->state |= ZSTATE_INIT;
return (1);
}
}
@@ -196,9 +177,6 @@ ZIPPreEncode(TIFF* tif, tsample_t s)
(void) s;
assert(sp != NULL);
- if( sp->state != ZSTATE_INIT_ENCODE )
- tif->tif_setupencode( tif );
-
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
return (deflateReset(&sp->stream) == Z_OK);
@@ -213,9 +191,6 @@ ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
ZIPState *sp = EncoderState(tif);
static const char module[] = "ZIPEncode";
- assert(sp != NULL);
- assert(sp->state == ZSTATE_INIT_ENCODE);
-
(void) s;
sp->stream.next_in = bp;
sp->stream.avail_in = cc;
@@ -282,12 +257,12 @@ ZIPCleanup(TIFF* tif)
tif->tif_tagmethods.vgetfield = sp->vgetparent;
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;
+ if (sp->state&ZSTATE_INIT) {
+ /* NB: avoid problems in the library */
+ if (tif->tif_mode == O_RDONLY)
+ inflateEnd(&sp->stream);
+ else
+ deflateEnd(&sp->stream);
}
_TIFFfree(sp);
tif->tif_data = NULL;
@@ -304,7 +279,7 @@ ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap)
switch (tag) {
case TIFFTAG_ZIPQUALITY:
sp->zipquality = va_arg(ap, int);
- if ( sp->state&ZSTATE_INIT_ENCODE ) {
+ if (tif->tif_mode != O_RDONLY && (sp->state&ZSTATE_INIT)) {
if (deflateParams(&sp->stream,
sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
@@ -342,22 +317,11 @@ static const TIFFFieldInfo zipFieldInfo[] = {
int
TIFFInitZIP(TIFF* tif, int scheme)
{
- static const char module[] = "TIFFInitZIP";
ZIPState* sp;
assert( (scheme == COMPRESSION_DEFLATE)
|| (scheme == COMPRESSION_ADOBE_DEFLATE));
- /*
- * Merge codec-specific tag information.
- */
- if (!_TIFFMergeFieldInfo(tif, zipFieldInfo,
- TIFFArrayCount(zipFieldInfo))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "Merging Deflate codec-specific tags failed");
- return 0;
- }
-
/*
* Allocate state block so tag methods have storage to record values.
*/
@@ -371,8 +335,10 @@ TIFFInitZIP(TIFF* tif, int scheme)
sp->stream.data_type = Z_BINARY;
/*
- * Override parent get/set field methods.
+ * Merge codec-specific tag information and
+ * override parent get/set field methods.
*/
+ _TIFFMergeFieldInfo(tif, zipFieldInfo, TIFFArrayCount(zipFieldInfo));
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = ZIPVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
@@ -403,7 +369,7 @@ TIFFInitZIP(TIFF* tif, int scheme)
(void) TIFFPredictorInit(tif);
return (1);
bad:
- TIFFErrorExt(tif->tif_clientdata, module,
+ TIFFErrorExt(tif->tif_clientdata, "TIFFInitZIP",
"No space for ZIP state block");
return (0);
}
diff --git a/src/libtiff/tiff.h b/src/libtiff/tiff.h
index 358b54b..a1f52ad 100644
--- a/src/libtiff/tiff.h
+++ b/src/libtiff/tiff.h
@@ -1,4 +1,4 @@
-/* $Id: tiff.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tiff.h,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -43,7 +43,7 @@
* (http://partners.adobe.com/asn/developer/PDFS/TN/TIFF6.pdf)
*
* For Big TIFF design notes see the following link
- * http://www.remotesensing.org/libtiff/bigtiffdesign.html
+ * http://gdal.maptools.org/twiki/bin/view/libtiff/BigTIFFDesign
*/
#define TIFF_VERSION 42
#define TIFF_BIGTIFF_VERSION 43
diff --git a/src/libtiff/tiffio.h b/src/libtiff/tiffio.h
index eb14c36..541cc93 100644
--- a/src/libtiff/tiffio.h
+++ b/src/libtiff/tiffio.h
@@ -1,4 +1,4 @@
-/* $Id: tiffio.h,v 1.3 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tiffio.h,v 1.4 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -58,15 +58,14 @@ typedef struct tiff TIFF;
* 32-bit file offsets being the most important, and to ensure
* that it is unsigned, rather than signed.
*/
-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 int32 tsize_t; /* i/o size in bytes */
-typedef void* tdata_t; /* image data ref */
-typedef uint32 toff_t; /* file offset */
+typedef uint32 ttag_t; /* directory tag */
+typedef uint16 tdir_t; /* directory index */
+typedef uint16 tsample_t; /* sample number */
+typedef uint32 tstrip_t; /* strip number */
+typedef uint32 ttile_t; /* tile number */
+typedef int32 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__
@@ -97,6 +96,10 @@ typedef HFILE thandle_t; /* client data handle */
typedef void* thandle_t; /* client data handle */
#endif /* USE_WIN32_FILEIO */
+#ifndef NULL
+# define NULL (void *)0
+#endif
+
/*
* Flags to pass to TIFFPrintDirectory to control
* printing of data structures that are potentially
@@ -188,36 +191,35 @@ typedef void (*tileSeparateRoutine)
* RGBA-reader state.
*/
struct _TIFFRGBAImage {
- TIFF* tif; /* image handle */
- int stoponerr; /* stop on read error */
- int isContig; /* data is packed/separate */
- int alpha; /* type of alpha data present */
- uint32 width; /* image width */
- uint32 height; /* image height */
- uint16 bitspersample; /* image bits/sample */
- uint16 samplesperpixel; /* image samples/pixel */
- uint16 orientation; /* image orientation */
- uint16 req_orientation; /* requested orientation */
- uint16 photometric; /* image photometric interp */
- uint16* redcmap; /* colormap pallete */
- uint16* greencmap;
- uint16* bluecmap;
- /* get image data routine */
- int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
- /* put decoded strip/tile */
+ TIFF* tif; /* image handle */
+ int stoponerr; /* stop on read error */
+ int isContig; /* data is packed/separate */
+ int alpha; /* type of alpha data present */
+ uint32 width; /* image width */
+ uint32 height; /* image height */
+ uint16 bitspersample; /* image bits/sample */
+ uint16 samplesperpixel; /* image samples/pixel */
+ uint16 orientation; /* image orientation */
+ uint16 req_orientation; /* requested orientation */
+ uint16 photometric; /* image photometric interp */
+ uint16* redcmap; /* colormap pallete */
+ uint16* greencmap;
+ uint16* bluecmap;
+ /* get image data routine */
+ int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
union {
void (*any)(TIFFRGBAImage*);
- tileContigRoutine contig;
- tileSeparateRoutine separate;
- } put;
- TIFFRGBValue* Map; /* sample mapping array */
- uint32** BWmap; /* black&white map */
- uint32** PALmap; /* palette image map */
- TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */
- TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */
-
- int row_offset;
- int col_offset;
+ tileContigRoutine contig;
+ tileSeparateRoutine separate;
+ } put; /* put decoded strip/tile */
+ TIFFRGBValue* Map; /* sample mapping array */
+ uint32** BWmap; /* black&white map */
+ uint32** PALmap; /* palette image map */
+ TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */
+ TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */
+
+ int row_offset;
+ int col_offset;
};
/*
@@ -251,10 +253,6 @@ typedef struct {
#define LOGLUV_PUBLIC 1
#endif
-#if !defined(__GNUC__) && !defined(__attribute__)
-# define __attribute__(x) /*nothing*/
-#endif
-
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
@@ -351,8 +349,6 @@ 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);
@@ -437,10 +433,10 @@ extern TIFF* TIFFClientOpen(const char*, const char*,
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 void TIFFError(const char*, const char*, ...);
+extern void TIFFErrorExt(thandle_t, const char*, const char*, ...);
+extern void TIFFWarning(const char*, const char*, ...);
+extern void TIFFWarningExt(thandle_t, const char*, const char*, ...);
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
diff --git a/src/libtiff/tiffiop.h b/src/libtiff/tiffiop.h
index c8e9677..9f6cdf4 100644
--- a/src/libtiff/tiffiop.h
+++ b/src/libtiff/tiffiop.h
@@ -1,4 +1,4 @@
-/* $Id: tiffiop.h,v 1.4 2009/12/11 15:17:41 scuri Exp $ */
+/* $Id: tiffiop.h,v 1.5 2010/01/26 15:56:36 scuri Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@@ -57,13 +57,6 @@ 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.
-*/
-/* typedef TIFF_INT64_T int64; IMLIB */
-/* typedef TIFF_UINT64_T uint64; IMLIB */
-
#include "tiffio.h"
#include "tif_dir.h"
@@ -104,35 +97,29 @@ struct tiff {
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_FILLORDER 0x0003 /* natural bit fill order for machine */
+#define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */
+#define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */
+#define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */
+#define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */
+#define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */
+#define TIFF_SWAB 0x0080 /* byte swap file information */
+#define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */
+#define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */
+#define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */
+#define TIFF_MAPPED 0x0800 /* file is mapped into memory */
+#define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */
+#define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */
+#define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */
+#define TIFF_STRIPCHOP 0x8000 /* 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 */
@@ -177,8 +164,7 @@ struct tiff {
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 */
+ toff_t tif_size; /* size of mapped file region (bytes) */
TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc;/* unmap file method */
/* input/output callback methods */
@@ -287,7 +273,6 @@ 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 int TIFFInitDumpMode(TIFF*, int);
#ifdef PACKBITS_SUPPORT
diff --git a/src/libtiff/tiffvers.h b/src/libtiff/tiffvers.h
index 7108541..9744f8d 100644
--- a/src/libtiff/tiffvers.h
+++ b/src/libtiff/tiffvers.h
@@ -1,4 +1,4 @@
-#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.9.2\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
+#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.8.2\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 20091104
+#define TIFFLIB_VERSION 20060323
--
cgit v1.2.3