/*
* Setup a directory entry that references a
* samples/pixel array of SHORT values and
* (potentially) write the associated indirect
* values.
*/
static int
TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
{
uint16 buf[10], v;
uint16* w = buf;
int i, status, samples = tif->tif_dir.td_samplesperpixel;
if (samples > NITEMS(buf))
w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
TIFFGetField(tif, tag, &v);
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < samples; i++)
w[i] = v;
status = TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, samples, w);
if (w != buf)
_TIFFfree((char*) w);
return (status);
}
/*
* Setup a directory entry that references a
* samples/pixel array of SHORT values and
* (potentially) write the associated indirect
* values.
*/
static int
TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
{
uint16 buf[10], v;
uint16* w = buf;
uint16 i, samples = tif->tif_dir.td_samplesperpixel;
int status;
if (samples > NITEMS(buf)) {
w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
if (w == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"No space to write per-sample shorts");
return (0);
}
}
TIFFGetField(tif, tag, &v);
for (i = 0; i < samples; i++)
w[i] = v;
dir->tdir_tag = (uint16) tag;
dir->tdir_type = (uint16) TIFF_SHORT;
dir->tdir_count = samples;
status = TIFFWriteShortArray(tif, dir, w);
if (w != buf)
_TIFFfree((char*) w);
return (status);
}
/*
* Setup a pair of shorts that are returned by
* value, rather than as a reference to an array.
*/
static int
TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
{
uint16 v[2];
TIFFGetField(tif, tag, &v[0], &v[1]);
return (TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, 2, v));
}
/*
* Setup a SHORT directory entry
*/
static void
TIFFSetupShort(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint16 v)
{
dir->s.tdir_tag = (uint16) tag;
TDIRSetEntryCount(tif,dir, 1);
dir->s.tdir_type = TIFF_SHORT;
TIFFWriteShortArray(tif, dir, &v);
}
/*
* Setup a pair of shorts that are returned by
* value, rather than as a reference to an array.
*/
static int
TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
{
uint16 v[2];
TIFFGetField(tif, tag, &v[0], &v[1]);
dir->tdir_tag = (uint16) tag;
dir->tdir_type = (uint16) TIFF_SHORT;
dir->tdir_count = 2;
return (TIFFWriteShortArray(tif, dir, v));
}
/*
* Setup a directory entry with either a SHORT
* or LONG type according to the value.
*/
static void
TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v)
{
dir->s.tdir_tag = (uint16) tag;
TDIRSetEntryCount(tif,dir, 1);
if (v > 0xffffL) {
dir->s.tdir_type = TIFF_LONG;
TDIRSetEntryOff(tif,dir, v);
} else {
uint16 iv = (uint16) v;
dir->s.tdir_type = TIFF_SHORT;
TIFFWriteShortArray(tif, dir, &iv);
}
}
/*
* Setup a directory entry that references a
* samples/pixel array of SHORT values and
* (potentially) write the associated indirect
* values.
*/
static int
TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
{
uint16 buf[10], v;
uint16* w = buf;
int i, status, samples = tif->tif_dir.td_samplesperpixel;
if (samples > (int)NITEMS(buf))
w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
TIFFGetField(tif, tag, &v);
for (i = 0; i < samples; i++)
w[i] = v;
status = TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, samples, w);
if (w != buf)
_TIFFfree((char*) w);
return (status);
}
/*
* Write an array of ``type'' values for a specified tag (i.e. this is a tag
* which is allowed to have different types, e.g. SMaxSampleType).
* Internally the data values are represented as double since a double can
* hold any of the TIFF tag types (yes, this should really be an abstract
* type tany_t for portability). The data is converted into the specified
* type in a temporary buffer and then handed off to the appropriate array
* writer.
*/
static int
TIFFWriteAnyArray(TIFF* tif,
TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
{
char buf[10 * sizeof(double)];
char* w = buf;
int i, status = 0;
if (n * TIFFDataWidth(type) > sizeof buf) {
w = (char*) _TIFFmalloc(n * TIFFDataWidth(type));
if (w == NULL) {
TIFFError(tif->tif_name,
"No space to write array");
return (0);
}
}
switch (type) {
case TIFF_BYTE:
{ uint8* bp = (uint8*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (uint8) v[i];
dir->tdir_tag = (uint16) tag;
dir->tdir_type = (short) type;
dir->tdir_count = n;
if (!TIFFWriteByteArray(tif, dir, (char*) bp))
goto out;
}
break;
case TIFF_SBYTE:
{ int8* bp = (int8*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (int8) v[i];
dir->tdir_tag = (uint16) tag;
dir->tdir_type = (short) type;
dir->tdir_count = n;
if (!TIFFWriteByteArray(tif, dir, (char*) bp))
goto out;
}
break;
case TIFF_SHORT:
{ uint16* bp = (uint16*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (uint16) v[i];
if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
goto out;
}
break;
case TIFF_SSHORT:
{ int16* bp = (int16*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (int16) v[i];
if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
goto out;
}
break;
case TIFF_LONG:
{ uint32* bp = (uint32*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (uint32) v[i];
if (!TIFFWriteLongArray(tif, type, tag, dir, n, bp))
goto out;
}
break;
case TIFF_SLONG:
{ int32* bp = (int32*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (int32) v[i];
if (!TIFFWriteLongArray(tif, type, tag, dir, n, (uint32*) bp))
goto out;
}
break;
case TIFF_FLOAT:
{ float* bp = (float*) w;
for (i = 0; i < (int) n; i++)
bp[i] = (float) v[i];
if (!TIFFWriteFloatArray(tif, type, tag, dir, n, bp))
goto out;
}
break;
case TIFF_DOUBLE:
return (TIFFWriteDoubleArray(tif, type, tag, dir, n, v));
default:
/* TIFF_NOTYPE */
/* TIFF_ASCII */
/* TIFF_UNDEFINED */
/* TIFF_RATIONAL */
/* TIFF_SRATIONAL */
goto out;
}
status = 1;
out:
if (w != buf)
_TIFFfree(w);
return (status);
}
/*
* Process tags that are not special cased.
*/
static int
TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
{
uint16 wc = (uint16) fip->field_writecount;
uint32 wc2;
dir->tdir_tag = (uint16) fip->field_tag;
dir->tdir_type = (uint16) fip->field_type;
dir->tdir_count = wc;
switch (fip->field_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
if (fip->field_passcount) {
uint16* wp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &wp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &wp);
dir->tdir_count = wc;
}
if (!TIFFWriteShortArray(tif, dir, wp))
return 0;
} else {
if (wc == 1) {
uint16 sv;
TIFFGetField(tif, fip->field_tag, &sv);
dir->tdir_offset =
TIFFInsertData(tif, dir->tdir_type, sv);
} else {
uint16* wp;
TIFFGetField(tif, fip->field_tag, &wp);
if (!TIFFWriteShortArray(tif, dir, wp))
return 0;
}
}
break;
case TIFF_LONG:
case TIFF_SLONG:
case TIFF_IFD:
if (fip->field_passcount) {
uint32* lp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &lp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &lp);
dir->tdir_count = wc;
}
if (!TIFFWriteLongArray(tif, dir, lp))
return 0;
} else {
if (wc == 1) {
/* XXX handle LONG->SHORT conversion */
TIFFGetField(tif, fip->field_tag,
&dir->tdir_offset);
} else {
uint32* lp;
TIFFGetField(tif, fip->field_tag, &lp);
if (!TIFFWriteLongArray(tif, dir, lp))
return 0;
}
}
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
if (fip->field_passcount) {
float* fp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &fp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &fp);
dir->tdir_count = wc;
}
if (!TIFFWriteRationalArray(tif, dir, fp))
return 0;
} else {
if (wc == 1) {
float fv;
TIFFGetField(tif, fip->field_tag, &fv);
if (!TIFFWriteRationalArray(tif, dir, &fv))
return 0;
} else {
float* fp;
TIFFGetField(tif, fip->field_tag, &fp);
if (!TIFFWriteRationalArray(tif, dir, fp))
return 0;
}
}
break;
case TIFF_FLOAT:
if (fip->field_passcount) {
float* fp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &fp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &fp);
dir->tdir_count = wc;
}
if (!TIFFWriteFloatArray(tif, dir, fp))
return 0;
} else {
if (wc == 1) {
float fv;
TIFFGetField(tif, fip->field_tag, &fv);
if (!TIFFWriteFloatArray(tif, dir, &fv))
return 0;
} else {
float* fp;
TIFFGetField(tif, fip->field_tag, &fp);
if (!TIFFWriteFloatArray(tif, dir, fp))
return 0;
}
}
break;
case TIFF_DOUBLE:
if (fip->field_passcount) {
double* dp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &dp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &dp);
dir->tdir_count = wc;
}
if (!TIFFWriteDoubleArray(tif, dir, dp))
return 0;
} else {
if (wc == 1) {
double dv;
TIFFGetField(tif, fip->field_tag, &dv);
if (!TIFFWriteDoubleArray(tif, dir, &dv))
return 0;
} else {
double* dp;
TIFFGetField(tif, fip->field_tag, &dp);
if (!TIFFWriteDoubleArray(tif, dir, dp))
return 0;
}
}
break;
case TIFF_ASCII:
{
char* cp;
if (fip->field_passcount)
TIFFGetField(tif, fip->field_tag, &wc, &cp);
else
TIFFGetField(tif, fip->field_tag, &cp);
dir->tdir_count = (uint32) (strlen(cp) + 1);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
case TIFF_BYTE:
case TIFF_SBYTE:
if (fip->field_passcount) {
char* cp;
if (wc == (uint16) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &cp);
dir->tdir_count = wc2;
} else { /* Assume TIFF_VARIABLE */
TIFFGetField(tif, fip->field_tag, &wc, &cp);
dir->tdir_count = wc;
}
if (!TIFFWriteByteArray(tif, dir, cp))
return 0;
} else {
if (wc == 1) {
char cv;
TIFFGetField(tif, fip->field_tag, &cv);
if (!TIFFWriteByteArray(tif, dir, &cv))
return 0;
} else {
char* cp;
TIFFGetField(tif, fip->field_tag, &cp);
if (!TIFFWriteByteArray(tif, dir, cp))
return 0;
}
}
break;
case TIFF_UNDEFINED:
{ char* cp;
if (wc == (unsigned short) TIFF_VARIABLE) {
TIFFGetField(tif, fip->field_tag, &wc, &cp);
dir->tdir_count = wc;
} else if (wc == (unsigned short) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &cp);
dir->tdir_count = wc2;
} else
TIFFGetField(tif, fip->field_tag, &cp);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
case TIFF_NOTYPE:
break;
}
return (1);
}
/*
* Write an array of ``type'' values for a specified tag (i.e. this is a tag
* which is allowed to have different types, e.g. SMaxSampleType).
* Internally the data values are represented as double since a double can
* hold any of the TIFF tag types (yes, this should really be an abstract
* type tany_t for portability). The data is converted into the specified
* type in a temporary buffer and then handed off to the appropriate array
* writer.
*/
static int
TIFFWriteAnyArray(TIFF* tif,
TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
{
char buf[10 * sizeof(double)];
char* w = buf;
int i, status = 0;
if (n * TIFFDataWidth(type) > sizeof buf)
w = (char*) _TIFFmalloc(n * TIFFDataWidth(type));
switch (type) {
case TIFF_BYTE:
{ unsigned char* bp = (unsigned char*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (unsigned char) v[i];
dir->tdir_tag = tag;
dir->tdir_type = (short) type;
dir->tdir_count = n;
if (!TIFFWriteByteArray(tif, dir, (char*) bp))
goto out;
}
break;
case TIFF_SBYTE:
{ signed char* bp = (signed char*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (signed char) v[i];
dir->tdir_tag = tag;
dir->tdir_type = (short) type;
dir->tdir_count = n;
if (!TIFFWriteByteArray(tif, dir, (char*) bp))
goto out;
}
break;
case TIFF_SHORT:
{ uint16* bp = (uint16*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (uint16) v[i];
if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
goto out;
}
break;
case TIFF_SSHORT:
{ int16* bp = (int16*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (int16) v[i];
if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
goto out;
}
break;
case TIFF_LONG:
{ uint32* bp = (uint32*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (uint32) v[i];
if (!TIFFWriteLongArray(tif, type, tag, dir, n, bp))
goto out;
}
break;
case TIFF_SLONG:
{ int32* bp = (int32*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (int32) v[i];
if (!TIFFWriteLongArray(tif, type, tag, dir, n, (uint32*) bp))
goto out;
}
break;
case TIFF_FLOAT:
{ float* bp = (float*) w;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for (i = 0; i < n; i++)
bp[i] = (float) v[i];
if (!TIFFWriteFloatArray(tif, type, tag, dir, n, bp))
goto out;
}
break;
case TIFF_DOUBLE:
return (TIFFWriteDoubleArray(tif, type, tag, dir, n, v));
default:
/* TIFF_NOTYPE */
/* TIFF_ASCII */
/* TIFF_UNDEFINED */
/* TIFF_RATIONAL */
/* TIFF_SRATIONAL */
goto out;
}
status = 1;
out:
if (w != buf)
_TIFFfree(w);
return (status);
}
